二叉搜索树的总结

二叉搜索树（BinarySearchTree)：

1）特点：
1. 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。
2. 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。
3. 右子树上所有节点的关键码（key）都大于根节点的关键码（key）。
4. 左右子树都是二叉搜索树

2）插入操作：

<span style="white-space:pre">	</span>bool Insert(const K &key,const V &value)
{
if(_root == NULL)
{
_root = new Node(key,value);
return true;
}
Node *cur = _root;
Node *parent = NULL;
while(cur != NULL)
{
if(cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if(cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
return false;
}
Node *node = new Node(key,value);
if(key > parent->_key)
{
parent->_right = node;
return true;
}
else
{
parent->_left = node;
return true;
}
}

递归实现：

<span style="white-space:pre">	</span>bool _Insert_R(Node* &root,const K &key,const V &value)
{
if(root == NULL)
{
root = new Node(key,value);
return true;
}
if(key > root->_key)
return _Insert_R(root->_right,key,value);
if(key < root->_key)
return _Insert_R(root->_left,key,value);
else
return false;
}

3）删除操作：

<span style="white-space:pre">	</span>bool Remove(const K &key)
{
if(_root ->_left == NULL && _root->_right == NULL)
{
delete _root;
_root = NULL;
return true;
}
Node *del = _root;
Node *parent = _root;
while(del != NULL)
{
if(del->_key > key)
{
parent = del;
del = del->_left;
}
else if(del->_key < key)
{
parent = del;
del = del->_right;
}
else
break;
}
if(del != NULL)
{
if(del->_left == NULL)     //缺左子树就用右子树来补
{
if(del != _root)
{
if(parent->_left = del)
parent->_left = del->_right;
else
parent->_right = del->_right;
}
else
{
_root = del->_right;
}
}
else if(del->_right == NULL)   //缺右子树就用左子树来补
{
if(del != _root)
{
if(parent->_left = del)
parent->_left = del->_left;
else
parent->_right = del->_left;
}
else
{
_root = del->_left;
}
}
else     //左右都不为空就与右子树上中序遍历的第一个数交换
{
Node *firstInOrder = del->_right;
parent = del;
while(firstInOrder->_left == NULL)
{
parent = firstInOrder;
firstInOrder = firstInOrder->_left;
}
swap(del->_key,firstInOrder->_key);
swap(del->_value,firstInOrder->_value);
del = firstInOrder;

if(parent->_left = del)    //firstInOrder的左数必为空
parent->_left = del->_right;
else
parent->_right = del->_right;
}
delete del;
return true;
}
else
{
return false;
}

}

递归实现：

<span style="white-space:pre">	</span>bool _Remove_R(Node * &root,const K &key)
{
if(root == NULL)
{
return false;
}
if(root->_key > key)
_Remove_R(root->_left,key);
else if(root->_key < key)
_Remove_R(root->_right,key);
else                    //root->_key == key
{
Node *del;
if(root->_left == NULL)     //缺左子树就用右子树来补
{
delete root
root = root->_right;
}
else if(del->_right == NULL)   //缺右子树就用左子树来补
{
delete root;
root = root->_left;
}
else     //左右都不为空就与右子树上中序遍历的第一个数交换
{
Node *firstInOrder = root->_right;
while(firstInOrder->_left == NULL)
{
firstInOrder = firstInOrder->_left;
}
swap(root->_key,firstInOrder->_key);
swap(root->_value,firstInOrder->_value;

return _Remove_R(root->_right,key);
}
}