(1) 左子树不空，则左子树上的所有结点的值均小于根结点的值
(2) 右子树不空，则右子树上的所有结点的值均大于根结点的值
二叉查找树可以为空，二叉查找树是递归定义的，也就是说其左右子树也为二叉查找树。
二叉查找树是一种动态查找表，可以进行动态地插入和删除。前面的定义中我们假定二叉查找树不含有相同元素。
由定义可知二叉查找树的中序序列为一个递增序列
常见的二叉查找树操作有求最小元素findMin()，求最大元素findMax()，判断查找树是否非空isEmpty()，判断是否包含给定元素contains()，输出所有元素printTree()，置空查找树makeEmpty()，向查找树中插入给定元素x，insert(x)，在查找树中删除给定元素x，remove(x)。
下面先讨论最重要的插入和删除操作，接着给出完整的C风格实现。
1、基本结构定义
class Student
{
public:
int key;
string major;
Student(int k=int(),string s="") : key(k), major(s){}
void operator=(const Student& rhs);
};
typedef Student ElementType;
typedef int KeyType;
typedef struct BSTNode
{
ElementType data;
struct BSTNode* lchild;
struct BSTNode* rchild;
}BSTNode, *BST;
详细信息请看后面完整程序
2、插入
(1) 不允许插入相同关键字，若二叉查找树中存在该关键字，则不插入
(2) 我们可以先检索二叉树，看查找树中是否含有该关键字，若不存在，再做一次扫描将结点插入到适当位置。使用这种方式，为插入一个该关键字，做了两次扫描。
(3) 注意到，插入的结点总是作为某一叶子节点的子结点，我们可以在第一次扫描过程中就确定待插入的位置，即把查找是否存在该关键字和查找可能的插入点在一次扫描中完成，提高插入效率。
(4) 查找递归实现
/*
description:在以t为根结点的二叉查找树中，查找关键字为key的结点
若查找成功，指针p指向该结点，返回true,
否则指向查找路径上的最后一个结点并返回false
指针f指向根结点t的父节点
*/
bool searchBST_recursion(BST t, KeyType key, BSTNode* f, BSTNode*& p)
{
if(t == NULL)//查找失败
{
p = f;
return false;
}
else if(key == t->data.key)//查找成功
{
p = t;
return true;
}
else if(key < t->data.key)
return searchBST_recursion(t->lchild,key,t,p);//左子树中继续查找
else
return searchBST_recursion(t->rchild,key,t,p);//右子树中继续查找
}
(5) 查找非递归实现
bool searchBST(BST t, KeyType key, BSTNode* f, BSTNode* &p)
{
while(t && key != t->data.key)
{
f = t;
if(key < t->data.key)
{
t = t->lchild;
}
else
{
t = t->rchild;
}
}
if(t)//查找成功
{
p = t;
return true;
}
else
{
p = f;
return false;
}
}
(6) 插入给定元素
void insertBST(BST& t,ElementType elem)
{
BSTNode * p = NULL;
if(!searchBST(t, elem.key, NULL, p))//查找失败，不含该关键字，可以插入
{
BSTNode * s = new BSTNode;
s->data = elem;//可能需要重载=
s->lchild = NULL;
s->rchild = NULL;
if(p == NULL)//查找树为空
{
t = s;//置s为根结点
}
else if(elem.key < p->data.key)
{
p->lchild = s; //*s为p左结点
}
else
{
p->rchild = s; //*s为p右结点
}
}
}
3、删除
在二叉查找树中删除一个给定的结点p有三种情况
(1) 结点p无左右子树，则直接删除该结点，修改父节点相应指针
(2) 结点p有左子树（右子树），则把p的左子树（右子树）接到p的父节点上
(3) 左右子树同时存在，则有三种处理方式
a. 找到结点p的中序直接前驱结点s，把结点s的数据转移到结点p，然后删除结点s，由于结点s为p的左子树中最右的结点，因而s无右子树，删除结点s可以归结到情况(2)。严蔚敏数据结构P230-231就是该处理方式。
b. 找到结点p的中序直接后继结点s，把结点s的数据转移到结点p，然后删除结点s，由于结点s为p的右子树总最左的结点，因而s无左子树，删除结点s可以归结到情况(2)。算法导论第2版P156-157该是该处理方式。
c. 找到p的中序直接前驱s，将p的左子树接到父节点上，将p的右子树接到s的右子树上，然后删除结点p。
使用处理方式a的代码如下：
//从二叉查找树中删除指针p所指向的结点 ,p非空,删除前驱方式
void removeNode1(BSTNode *& p)
{
BSTNode *q = NULL;
if(!p->rchild)//*p的右子树为空
{
q = p;
p = p->lchild;
delete q;
}
else if(!p->lchild)//*p的左子树为空
{
q = p;
p = p->rchild;
delete q;
}
else//左右子树均不空
{
BSTNode *s = NULL;
q = p;
s = p->lchild; //左子树根结点
while(s->rchild) //寻找结点*p的中序前驱结点，
{ //也就是以p->lchild为根结点的子树中最右的结点
q = s; //*s指向*p的中序前驱
s = s->rchild; //*q指向*s的父节点
}
p->data = s->data; //*s结点中的数据转移到*p结点，然后删除*s
if(q != p) //p->lchild右子树非空
{
q->rchild = s->lchild;//把*s的左子树接到*q的右子树上
}
else //p->lchild右子树为空 ,此时q ==p
{
q->lchild = s->lchild;//把*s的左子树接到*q的左子树上
}
delete s; //删除结点*s
}
}使用处理方式b的代码如下：
//从二叉查找树中删除指针p所指向的结点 ,p非空,删除后继方式
void removeNode2(BSTNode *& p)
{
BSTNode *q = NULL;
if(!p->rchild)//*p的右子树为空
{
q = p;
p = p->lchild;
delete q;
}
else if(!p->lchild)//*p的左子树为空
{
q = p;
p = p->rchild;
delete q;
}
else//左右子树均不空
{
BSTNode *s = NULL;
q = p;
s = p->rchild; //右子树根结点
while(s->lchild) //寻找结点*p的中序后继结点，
{ //也就是以p->rchild为根结点的子树中最左的结点
q = s; //*s指向*p的中序后继
s = s->lchild; //*q指向*s的父节点
}
p->data = s->data; //*s结点中的数据转移到*p结点，然后删除*s
if(q != p) //p->rchild左子树非空
{
q->lchild = s->rchild;//把*s的右子树接到*q的左子树上
}
else //p->rchild左子树为空 ,此时q ==p
{
q->rchild = s->rchild;//把*s的右子树接到*q的右子树上
}
delete s; //删除结点*s
}
}使用处理方式c的代码如下：
//从二叉查找树中删除指针p所指向的结点 ,p非空,直接删除p的方式
void removeNode3(BSTNode *& p)
{
BSTNode *q = NULL;
if(!p->rchild)//*p的右子树为空
{
q = p;
p = p->lchild;
delete q;
}
else if(!p->lchild)//*p的左子树为空
{
q = p;
p = p->rchild;
delete q;
}
else//左右子树均不空
{
BSTNode *s = NULL;
q = p;
s = p->lchild; //左子树根结点
while(s->rchild) //寻找结点*p的中序前驱结点，
{ //也就是以*s为根结点的子树中最右的结点
s = s->rchild;
}
s->rchild = p->rchild;//*p的右子树接到*s的右子树上
p = p->lchild; //*p的左子树接到父节点上
delete q; //删除结点*q
}
}在二叉查找树中删除含有给定关键字的元素结点的递归函数如下：
//删除关键字为key的元素结点 -递归
void removeBST_recursion(BST& t, KeyType key)
{
if(t)
{
if(key < t->data.key)
{
removeBST_recursion(t->lchild,key);
}
else if(t->data.key < key)
{
removeBST_recursion(t->rchild,key);
}
else//找到关键字为key的元素
{
// removeNode1(t);//删除结点*t
// removeNode2(t);
removeNode3(t);
}
}
}注：
(1)由于该函数是递归的，且用到了指针引用，我们在前面的删除给定结点p的函数中，修改p就相当于修改了父节点，这是和C中不同的地方，在C中要达到这种效果，可以使用指向指针的指针变量。
(2)只给出了该函数的递归实现，没有给出非递归实现，是为了避免把代码弄乱。要实现非递归，可以修改前面的删除结点p的函数，添加一个指向结点p的父节点的指针引用f。同时要修改查找是否存在关键字为key的非递归查找函数，使其在得到p的同时，可以得到其父节点。这样我们在实现非递归时，只需扫描一遍，即调用查找函数，如果有该关键字，我们就可以得到指向该结点的指针p和指向结点p的父节点f，然后调用删除给定结点p的函数即可。
4、完整测试程序
#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
int key;
string major;
//other data
Student(int k=int(),string s="") : key(k), major(s){}
//重载赋值运算符
void operator=(const Student& rhs)
{
if(this != &rhs)
{
key = rhs.key;
major = rhs.major;
}
}
};
//重载<<,便于输出自定义类对象
ostream& operator<<(ostream &out, const Student& s)
{
out<<"("<<s.key<<","<<s.major<<")";
}
typedef Student ElementType;
typedef int KeyType;
typedef struct BSTNode
{
ElementType data;
struct BSTNode* lchild;
struct BSTNode* rchild;
}BSTNode, *BST;
/*
description:在以t为根结点的二叉查找树中，查找关键字为key的结点
若查找成功，指针p指向该结点，返回true,
否则指向查找路径上的最后一个结点并返回false
指针f指向根结点t的父节点
*/
//bool searchBST_recursion(BST t, KeyType key, BSTNode* f, BSTNode*& p)
//{
// if(t == NULL)//查找失败
// {
// p = f;
// return false;
// }
// else if(key == t->data.key)//查找成功
// {
// p = t;
// return true;
// }
// else if(key < t->data.key)
// return searchBST_recursion(t->lchild,key,t,p);//左子树中继续查找
// else
// return searchBST_recursion(t->rchild,key,t,p);//右子树中继续查找
//}
//非递归查找
bool searchBST(BST t, KeyType key, BSTNode* f, BSTNode* &p)
{
while(t && key != t->data.key)
{
f = t;
if(key < t->data.key)
{
t = t->lchild;
}
else
{
t = t->rchild;
}
}
if(t)//查找成功
{
p = t;
return true;
}
else
{
p = f;
return false;
}
}
//插入给定元素
void insertBST(BST& t,ElementType elem)
{
BSTNode * p = NULL;
if(!searchBST(t, elem.key, NULL, p))//查找失败，不含该关键字，可以插入
{
BSTNode * s = new BSTNode;
s->data = elem;//可能需要重载=
s->lchild = NULL;
s->rchild = NULL;
if(p == NULL)//查找树为空
{
t = s;//置s为根结点
}
else if(elem.key < p->data.key)
{
p->lchild = s; //*s为p左结点
}
else
{
p->rchild = s; //*s为p右结点
}
}
}
//从二叉查找树中删除指针p所指向的结点 ,p非空,删除前驱方式
void removeNode1(BSTNode *& p)
{
BSTNode *q = NULL;
if(!p->rchild)//*p的右子树为空
{
q = p;
p = p->lchild;
delete q;
}
else if(!p->lchild)//*p的左子树为空
{
q = p;
p = p->rchild;
delete q;
}
else//左右子树均不空
{
BSTNode *s = NULL;
q = p;
s = p->lchild; //左子树根结点
while(s->rchild) //寻找结点*p的中序前驱结点，
{ //也就是以p->lchild为根结点的子树中最右的结点
q = s; //*s指向*p的中序前驱
s = s->rchild; //*q指向*s的父节点
}
p->data = s->data; //*s结点中的数据转移到*p结点，然后删除*s
if(q != p) //p->lchild右子树非空
{
q->rchild = s->lchild;//把*s的左子树接到*q的右子树上
}
else //p->lchild右子树为空 ,此时q ==p
{
q->lchild = s->lchild;//把*s的左子树接到*q的左子树上
}
delete s; //删除结点*s
}
}
//从二叉查找树中删除指针p所指向的结点 ,p非空,删除后继方式
void removeNode2(BSTNode *& p)
{
BSTNode *q = NULL;
if(!p->rchild)//*p的右子树为空
{
q = p;
p = p->lchild;
delete q;
}
else if(!p->lchild)//*p的左子树为空
{
q = p;
p = p->rchild;
delete q;
}
else//左右子树均不空
{
BSTNode *s = NULL;
q = p;
s = p->rchild; //右子树根结点
while(s->lchild) //寻找结点*p的中序后继结点，
{ //也就是以p->rchild为根结点的子树中最左的结点
q = s; //*s指向*p的中序后继
s = s->lchild; //*q指向*s的父节点
}
p->data = s->data; //*s结点中的数据转移到*p结点，然后删除*s
if(q != p) //p->rchild左子树非空
{
q->lchild = s->rchild;//把*s的右子树接到*q的左子树上
}
else //p->rchild左子树为空 ,此时q ==p
{
q->rchild = s->rchild;//把*s的右子树接到*q的右子树上
}
delete s; //删除结点*s
}
}
//从二叉查找树中删除指针p所指向的结点 ,p非空,直接删除p的方式
void removeNode3(BSTNode *& p)
{
BSTNode *q = NULL;
if(!p->rchild)//*p的右子树为空
{
q = p;
p = p->lchild;
delete q;
}
else if(!p->lchild)//*p的左子树为空
{
q = p;
p = p->rchild;
delete q;
}
else//左右子树均不空
{
BSTNode *s = NULL;
q = p;
s = p->lchild; //左子树根结点
while(s->rchild) //寻找结点*p的中序前驱结点，
{ //也就是以*s为根结点的子树中最右的结点
s = s->rchild;
}
s->rchild = p->rchild;//*p的右子树接到*s的右子树上
p = p->lchild; //*p的左子树接到父节点上
delete q; //删除结点*q
}
}
//删除关键字为key的元素结点 -递归
void removeBST_recursion(BST& t, KeyType key)
{
if(t)
{
if(key < t->data.key)
{
removeBST_recursion(t->lchild,key);
}
else if(t->data.key < key)
{
removeBST_recursion(t->rchild,key);
}
else//找到关键字为key的元素
{
// removeNode1(t);//删除结点*t
// removeNode2(t);
removeNode3(t);
}
}
}
//输出二叉查找树，中序递归
void printTree(const BST & t)
{
if(t)
{
printTree(t->lchild);
cout<<t->data<<" ";
printTree(t->rchild);
}
}
int main(int argc, char *argv[])
{
const int N = 10;
BST root = NULL;
for(int i=1; i<=N; i++)
{
Student s(i,"cs");//关键字为1-10
insertBST(root,s);
}
cout<<"after insert: "<<endl;
printTree(root);
cout<<endl<<endl;
for(int i=1;i<=N;i+=2)
{
removeBST_recursion(root,i);//删除关键字为1-3-5-7-9的结点
}
cout<<"after delete: "<<endl;
printTree(root);
cout<<endl<<endl;
system("PAUSE");
return EXIT_SUCCESS;
}5、二叉查找树类的完整C++实现请看：http://blog.csdn.net/sysu_arui/article/details/7892593
参考资料：
[1]严蔚敏《数据结构(C语言版)》
[2]算法导论（第2版）
