概念：
二叉搜索树：又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树
1.若它的左子树不为空，则它的左子树上所有节点的值都小于根节点的值
2.若它的右子树不为空，则它的右子树上所有节点的值都大于根节点的值
3.它的左右字数也都为二叉搜索树
操作：
搜索：
若根结点不为空：
如果根节点的key==查找的key 返回true
如果节点的key>查找的key 在左子树中找
如果节点的key<查找的key 在右子树中找
否则 返回false
插入：如果根节点为空，直接插入，如果根节点不为空，先检测新插入节点是否在树中存在，如果存在返回false，如果不存在，找到合适的位置插入
删除：
首先查找元素是否在二叉搜索树中，如果不存在，则返回；
否则要删除的结点可能分下面四种 情况：
1、要删除的结点无孩子结点；
2、要删除的结点只有左孩子结点；
3、要删除的结点只有右孩子结点；
4、要删除的结点有左、右孩子结点；
对于上述情况，相应的删除方法如下：
a、直接删除该结点
b、删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点；
c、删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点；
d、在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到 被删除节点中，在来处理该结点的删除问题
#pragma once
#include<iostream>
using namespace std;
template<class k,class v>
struct BSTreeNode
{
BSTreeNode<k,v>* _left;
BSTreeNode<k,v>* _right;
k _key;
v _value;
BSTreeNode<k,v>(const k&key ,const v&value)
:_left(NULL)
,_right(NULL)
,_key(key)
, _value(value)
{}
};
template <class k,class v>
class BSTree
{
typedef BSTreeNode<k,v> Node;
public:
BSTree()
:_root(NULL)
{}
bool Insert(const k& key,const v&value)
{
//1.没有节点 直接插入到第一个
if (_root == NULL)
{
_root = new Node(key,value);
return true;
}
//2.如果有节点，找到合适的位置插入
Node *parent = NULL;
Node *cur = _root;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key<key)
{
parent = cur;
cur = cur->_right;
}
else
return false;
}
if (parent->_key>key)
{
parent->_left = new Node(key,value);
}
else
{
parent->_right = new Node(key,value);
}
return true;
}
bool InsertR(const k& key, const v& value)//用递归实现
{
return _InsertR(_root, key, value);
}
Node* Find(const k& key)
{
if (_root == NULL)
{
return NULL;
}
Node *cur = _root;
while (cur)
{
if (cur->_key > key)
{
cur = cur->_left;
}
else if (cur->_key<key)
{
cur = cur->_right;
}
else
{
return cur;
}
}
return NULL;
}
bool Remove(const k& key)
{
if (_root == NULL)
{
return false;
}
//找到要删除的节点
Node *parent = NULL;
Node*del = _root;
while (del)
{
if (del->_key > key)
{
parent = del;
del = del->_left;
}
else if (del->_key < key)
{
parent = del;
del = del->_right;
}
else
{
break;
}
}
if (del)
{
if (del->_left == NULL) //要删除节点左节点为空
{
if (del == _root)
_root = del->_right;
else if (del == parent->_left)
parent->_left = del->_right;
else
parent->_right = del->_right;
}
else if (del->_right == NULL)//要删除节点的右节点为空
{
if (del == _root)
_root = del->_left;
else if (del == parent->_left)
parent->_left = del->_left;
else
parent->_right = del->_left;
}
else//要删除节点的左右节点都不为空
{
Node* cur = del->_right;
parent = del;
while (cur->_left)
{
parent = cur;
cur = cur->_left;
}
swap(_root->_key,cur->_key);
swap(_root->_value, cur->_value);
if (cur == parent->_left)
parent->_left = cur->_right;
else
parent->_right = cur->_right;
del = cur;
}
delete del;
del = NULL;
return true;
}
return false;
}
bool RemoveR(const k&key)//用递归实现
{
return _RemoveR(_root, key);
}
void InOderNonR()
{
_InOderNoR(_root);
cout << endl;
}
protected:
bool _Insert(Node *& _root,const k & key, const v &value)
{
if (_root == NULL)
{
_root = new Node(key, value);
return true;
}
if (_root->_key > key)
_Insert(_root->_left, key, value);
else if (_root->_key < key)
_Insert(_root->_left, key, value);
else
return false;
}
bool _RemoveR(Node *&_root, const k&key)
{
if (_root == NULL)
{
return false;
}
if (_root->_key > key)
{
_RemoveR(_root->_left, key);
}
else if (_root->_key < key)
{
_RemoveR(_root->_right, key);
}
else
{
Node* del = _root;
if (_root->_left == NULL)
{
_root = _root->_right;
}
else if (_root->_right == NULL)
{
_root = _root->_left;
}
else
{
Node*cur = _root->_right;
Node*parent = _root;
while (cur->_left)
{
parent = cur;
cur = cur->_left;
}
swap(_root->_key, cur->_key);
swap(_root->_value, cur->_value);
if (parent->left == cur)
{
parent->_left = cur->_right;
}
else
parent->_right = cur->_right;
del = cur;
}
delete del;
del = NULL;
}
return true;
}
void _InOderNoR(Node *_root)
{
if (_root == NULL)
{
return;
}
_InOderNoR(_root->_left);
cout << _root->_key << "_"<<_root->_value<<" ";
_InOderNoR(_root->_right);
}
private:
Node* _root;
};