二叉查找树，二叉搜索树，Binary Search Tree
二叉查找树性质：左孩子<双亲<右孩子
若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
任意节点的左、右子树也分别为二叉查找树。
没有键值相等的节点（no duplicate nodes）。
二叉查找树插入与删除
插入
1.若当前的二叉查找树为空，则插入的元素为根节点；
2.若插入的元素值小于根节点值，则将元素插入到左子树中；
3.若插入的元素值不小于根节点值，则将元素插入到右子树中。
删除
分三种情况进行处理：
1.p为叶子节点。
直接删除该节点，再修改其父节点的指针（注意分是根节点和不是根节点）。
2.p为单支节点（即只有左子树或右子树）。
让p的子树与p的父亲节点相连，删除p即可（注意分是根节点和不是根节点）。
3.p的左子树和右子树均不空。
（找后继，次大值）：找到p的后继y，因为y一定没有左子树，所以可以删除y，并让y的父亲节点成为y的右子树的父亲节点，并用y的值代替p的值；
二叉查找树实现
//BSTree.h
#ifndef BSTREE_HXX
#define BSTREE_HXX
#include <iostream>
using namespace std;
template <class T>
class BSTNode
{
public:
T key;
BSTNode *leftchild;
BSTNode *rigthchild;
BSTNode *parent;
BSTNode(T value, BSTNode *p, BSTNode *l, BSTNode *r):\
key(value),parent(),leftchild(l),right(r){}
};
template <class T>
class BSTree
{
private:
BSTNode<T> *root;
public:
BSTree();
~BSTree();
void preOrder();//先序遍历
void inOrder()://中序遍历
void postOrder();//后序遍历
BSTNode<T> * search(BSTNode<T> *tree,T key);//递归查找
BSTNode<T> * iterativeSearch(T key);//非递归查找
T minimum();//查找最小结点
T maximum();//查找最大结点
BSTNode<T> * successor(BSTNode<T> *x);//查找x的后继结点
BSTNode<T> * predecessor(BSTNode<T> *x);//查找x的前驱结点
void insert(T key);//插入
void remove(T key);//删除
void destroy();//销毁二叉树
}
#endif //BSTREE_HXX
//BSTree.cpp
#include "BSTree.h"
#include <iostream>
using namespace std;
template <class T>
BSTree<T>::BSTree():root(NULL)
{
}
template <class T>
BSTree<T>::~BSTree()
{
destroy();
}
template <class T>
void BSTree<T>::preOrder()
{
BSTNode<T> * tree = root;
if(tree != NULL)
{
cout<<tree->key<<" ";
preOrder(tree->leftchild);
preOrder(tree0>rightchild);
}
}
template <class T>
void BSTree<T>::inOrder()
{
BSTNode<T> * tree = root;
if(tree != NULL)
{
inOrder(tree->leftchild);
cout<<tree->key<<" ";
inOrder(tree0>rightchild);
}
}
template <class T>
void BSTree<T>::postOrder()
{
BSTNode<T> * tree = root;
if(tree != NULL)
{
postOrder(tree->leftchild);
postOrder(tree0>rightchild);
cout<<tree->key<<" ";
}
}
template <class T>
BSTNode<T> * BSTree<T>::search(BSTNode<T> *tree,T key)
{
tree = root;
if(tree == NULL || tree->key == key)
return tree;
if(key < tree->key)
return search(tree->leftchild,key);
if(key > tree->key)
return search(tree->rightchild,key);
}
template <class T>
BSTNode<T> * BSTree<T>::iterativeSearch(T key)
{
BSTNode<T> * tree = root;
while((tree != NULL) && (tree->key != key))
{
if(key < tree->key)
tree = tree->leftchild;
else
tree = tree->rightchild;
}
return tree;
}
template <class T>
T BSTree<T>::minimum()
{
BSTNode<T> * tree = root;
if(tree == NULL)
return NULL;
while(tree->leftchild != NULL)
tree = tree->leftchild;
return tree->key;
}
template <class T>
T BSTree<T>::maximum()
{
BSTNode<T> * tree = root;
if(tree == NULL)
return NULL;
while(tree->rightchild != NULL)
tree = tree->rightchild;
return tree->key;
}
//后继结点，次小结点
template <class T>
BSTNode<T> * BSTree<T>::successor(BSTNode<T> *x)
{
// 如果x存在右孩子，则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
if(x->rightchild != NULL)
return minimum(x->rightchild);
// 如果x没有右孩子。则x有以下两种可能：
// (01) x是"一个左孩子"，则"x的后继结点"为 "它的父结点"。
// (02) x是"一个右孩子"，则查找"x的最低的父结点，并且该父结点要具有左孩子"，找到的这个"最低的父结点"就是"x的后继结
BSTNode<T> * p = x->parent;
while((p != NULL) && (x == p->rightchild))
{
x = p;
p = p->parent;
}
return p;
}
//前驱结点，次大结点
template <class T>
BSTNode<T> * BSTree<T>::predecessor(BSTNode<T> *x)
{
if(x->leftchild != NULL)
return minimum(x->leftchild);
BSTNode<T> * p = x->parent;
while((p != NULL) && (x == p->leftchild))
{
x = p;
p = p->parent;
}
return p;
}
template <class T>
void BSTree<T>::insert(T key)
{
BSTNode<T> * p = NULL;
BSTNode<T> * x = root;
while(x!=NULL)
{
p = x;
if(key < x->key)
x = x->leftchild;
else
x = x->rightchild;
}
BSTNode<T> * newNode = new BSTNode<T>;
newNode->key = key;
newNode->parent = p;
if(p == NULL)
root = newNode;
elseif(newNode->key < p->key)
p->leftchild = newNode;
else
p->rightchild = newNode;
}
template <class T>
void BSTree<T>::remove(T key)
{
BSTNode<T> * x = NULL;
BSTNode<T> * y = NULL;
BSTNode<T> * tree = root;
BSTNode<T> * removeNode = search(root,key);
if((removeNode->leftchild == NULL) || (removeNode->rightchild == NULL))
y = removeNode;
else
y = successor(removeNode);
if(y->leftchild != NULL)
x = y->leftchild;
else
x = y->rightchild;
if(x != NULL)
x->parent = y->parent;
if(y->parent == NULL)
tree = x;
elseif(y == y->parent->leftchild)
y->parent->leftchild = x;
else
y->parent->rightchild = x;
if(y != removeNode)
removeNode->key = y->key;
delete y;
}
template <class T>
void BSTree<T>::destroy(BSTNode<T> * tree)
{
tree = root;
if(tree == NULL)
return;
if(tree->leftchild != NULL)
return destroy(tree->leftchild);
if(tree->rightchild != NULL)
return destroy(tree->rightchild);
delete tree;
tree = NULL;
}