二叉搜索树--基础篇
二叉搜索树Binary Search Tree（BSTs）又名二叉排序树，二叉查找树。而能够自平衡的叫平衡搜索树，包括AVL trees, 2-3 trees, 2-3-4 trees, B-trees, Red-Black Trees红黑树,skip lists跳跃表。
在二叉搜索树的基础上，又有最优二叉搜索树。
在此之前先说说三种遍历方式。
中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。在遍历左、右子树时，仍然先遍历左子树，再访问根结点，最后遍历右子树。即：
若二叉树为空则结束返回
否则：
（1）中序遍历左子树。
（2）访问根结点。
（3）中序遍历右子树。
中序遍历
注意的是：遍历左右子树时仍然采用中序遍历方法。
如右图所示二叉树
中序遍历结果：DBEAFC
中序遍历的时间复杂度为：O(n)。
如果一棵二叉排序树的节点值是数值，中序遍历的结果为升序排列的数组。可以利用该性质检测一棵树是否为二叉排序数。
已知前序遍历和后序遍历，不能确定唯一的中序遍历。
void BinTree::preOrder(Node *r)//递归实现先序遍历
{
if(r==NULL)
{
return ;
}
else
{
cout<<r->data<<" ";
preOrder(r->left);
preOrder(r->right);
}
}
void BinTree::InOrder(Node *r)//递归实现中序遍历 { if(r==NULL) { return ; } else { InOrder(r->left); cout<<r->data<<" "; InOrder(r->right); } } void BinTree::PostOrder(Node *r)//递归实现后序遍历 { if(r==NULL) { return ; } else { PostOrder(r->left); PostOrder(r->right); cout<<r->data<<" "; } }
一、二叉搜索树的定义
二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树：
每个结点都有一个作为搜索依据的关键码(key)，所有结点的关键码互不相同。
左子树（如果非空）上
所有结点的关键码都小于根结点的关键码。
右子树（如果非空）上所有结点的关键码都大于根结点的关键码。
左子树和右子树也是二叉搜索树。（构建的二叉搜索树和输入节点的排序有关，排序不同，构造的二叉树也不同）
如果对一棵二叉搜索树进行中序遍历，可以按从小到大的顺序，将各结点关键码排列起来，所以也称二叉搜索树为二叉排序树。
二、查询操作
在二叉搜索树中，查询操作时很核心的一个操作，在插入节点的时候，需要查看改节点是否已经存在，如果存在那么插入操作失败。并且在删除节点而不调整二叉树时，使用的策略和步骤是和查询操作一样的。
查询步骤如下：
假设想要在二叉搜索树中搜索关键码为
x
的元素，搜索过程从根结点开始。
如果
根指针（或者迭代的子树的根）为
NULL
，则
搜索不成功
；并报告该空节点的父亲节点，即最后停留在的叶子节点。
否则用给定值
x
与根结点的关键码进行比较：
若
给定值等于根结点关键码
，则
搜索成功
，返回搜索成功； 并报告搜索到结点地址。
若给定值小于根结点的关键码，则继续递归搜索根结点的左子树；
否则。递归搜索根结点的右子树。
/********************************************************************
Method: SearchBST
Description:
Access: public
Returns: int
Parameter: T: the tree that will be searched, f:the father tree of the
tree that will be searched p：point to the elements
that =key, or when result =0; point to the last leaf node
********************************************************************/
void SearchBST(BiTree T,int key,BiTree f,BiTree &p,int& result)
{
result = 0;
if(T == NULL)
{
p=f;
result = 0;
}
else if(key>T->data)
{
SearchBST(T->rchild,key,T,p,result);
}
else if(key<T->data)
{
SearchBST(T->lchild,key,T,p,result);
}
else if(key == T->data)
{
p=T;
result = 1;
}
}
使用返回值的版本如下：
int SearchBST(BiTree T,int key,BiTree f,BiTree &p)
{
int tmp1,tmp2;
tmp1=tmp2=0;
if(!T) {p=f;return 0;} //查找不成功
else if(key==T->data) {p=T;return 1;} //查找成功
else if(key<T->data) tmp1=SearchBST(T->lchild,key,T,p); //在左子树中继续查找
else tmp2=SearchBST(T->rchild,key,T,p); //在右子树中继续查找
if(tmp1||tmp2) return 1; //若在子树中查找成功，向上级返回1
else return 0; //否则返回0*/
}
三、插入操作
每次结点的插入，都要先进行搜索操作，（搜索不成功；报告该空节点的父亲节点，最后停留在的叶子节点）。然后把新结点作为改叶结点的子节点插入。
int InsertBST(BiTree &T,int key)
{
BiTree p,s;
int result = 0;
SearchBST(T,key,NULL,p,result);
if(result == 0) //查找不成功，插入
{
s = new BiTNode;
s->data=key;
s->lchild=s->rchild=NULL;
if(p == NULL) T=s; //被插结点*s为新的根结点
else if(key<p->data) p->lchild=s; //被插结点*s为左孩子
else p->rchild=s; //被插结点*s为右孩子
return 1; //成功插入
}
else return 0; //树中已存在关键字为e的数据元素
}
四、删除操作
在二叉搜索树中删除一个结点时，必须将因删除结点而断开的二叉链表重新链接起来，同时确保二叉搜索树的性质不会失去。
为保证在删除后树的搜索性能不至于降低，还需要防止重新链接后树的高度增加。
删除叶结点
，只需将其双亲结点指向它的指针清零，再释放它即可。如a所示
被删结点右子树为空
，可以拿它的左子女结点顶替它的位置，再释放它。
被删结点左子树为空
，可以拿它的右子女结点
顶替它的位置，再释放它。如b所示
被删结点左、右子树都不为空
，可以在它的右子树中寻找中序下的第一个结点
(
关键码最小
),
用它的值填补到被删结点中，再来处理这个结点的删除问题。（这个点需要一个比他大的最少的数）
在B中，16的左子树空，16用他的右子树填补
在C中，5的左右子树都不为空，采取找到右子树最小值（中序查找到的第一个值），将6填入5，然后6变成了一个hole，递归执行直到最后一个取代的值的左右子树有一个为空，结束。原则是这样子，但是一般都不会使用递归实现。
取代的是，p是5，q从5开始，s是5的右子树，即q一直是s的前驱。然后s向左走到尽头，q一直保存前驱，最后s变为6，q为10， 然后将p上的值存储为6，将6的右子树接入到10的左子树
第一步，做类似查找的操作：
void DeleteBST(BiTree &T,int key, int& result)
{
result = 0;
if(T==NULL)
{
result = 0; //要搜索的子树为空
}
else
{
if(key==T->data)//找到关键字等于key的数据元素并删除它
{
Delete(T); //在二叉排序树中删除结点p,并重接它的左或右子树
result = 1;
}
else if(key<T->data) //继续在左子树中删除
{
DeleteBST(T->lchild,key,result);
}
else //继续在右子树中删除
{
DeleteBST(T->rchild,key,result);
}
}
}
第二步、实现Delete(T)，删除节点p，重接它的 左右子树。
方法一：找到右子树最小的值。
方法二、找到左子树最大的值。
void Delete(BiTree &p)
{//在二叉排序树中删除结点p,并重接它的左或右子树
BiTree s,q;
if(p->rchild == NULL) //右子树空，只需重接它的左子树
{
cout<<"p value"<<p->data<<endl;
q=p;
p=p->lchild;
free(q);
}
else if(p->lchild == NULL) //左子树空，只需重接它的右子树
{
cout<<"p2 value"<<p->data<<endl;
q=p;
p=p->rchild;
free(q);
}
else //左右子树均不空
{
q=p;//q一直是s的前驱，负责保存s游走后的位置
s=p->rchild;//s不断向左游走，转右，向左走到尽头
while(s->lchild)
{
q=s;s=s->lchild;
}
p->data=s->data; //q的值也被改变
cout<<"s value"<<s->data<<endl;
cout<<"q value"<<q->data<<endl;
cout<<"p value"<<p->data<<endl;
if(q!=p) q->lchild=s->rchild;
else //删除78， 左右为65,94，q没有前进过地址没变，但是值变为了94
{
q->rchild=s->lchild;
}
free(s);
}
}
整个可执行程序的代码如下：
演示的二叉堆为：
</pre><p></p><div style="top: 576px;"><pre name="code" class="cpp">#include <iostream>
using namespace std;
#define Maxsize 100
typedef struct BiTNode //定义二叉树节点结构
{
int data; //结点的数据域
struct BiTNode *lchild,*rchild; //左右孩子指针域
}BiTNode,*BiTree;
BiTNode *CreatBST(int A[],int n);
void SearchBST(BiTree,int,BiTree,BiTree&,int& result); //在二叉排序树中查找元素
int InsertBST(BiTree &,int); //在二叉排序树中插入元素
int DeleteBST(BiTree &,int); //在二叉排序树中删除元素
void Delete(BiTree &); //删除二叉排序树的根结点
void InorderBST(BiTree); //中序遍历二叉排序树，并显示
void inorder(BiTree T);
int A[Maxsize];
BiTNode *CreatBST(int A[],int n) //由数组A中的关键字建立一棵二叉排序树
{
BiTNode *bt=NULL; //初始bt 为空树
int i=0;
while(i<n)
if(InsertBST(bt,A[i])==1) //将数组A[i]插入二叉排序树bt中
{
printf(" Step%d，Insert：%d:",i+1,A[i]);
InorderBST(bt);
printf("\n");
i++;
}
return bt; //返回建立的二叉排序树的根指针
}
void InorderBST(BiTree T)
{//以中序方式遍历二叉排序树T，并显示
if(T!=NULL)
{
printf("%d",T->data);
if(T->lchild!=NULL||T->rchild!=NULL)
{
printf("(");
InorderBST(T->lchild);//递归调用中序遍历函数
if(T->rchild!=NULL)
printf(",");
InorderBST(T->rchild); //递归调用中序遍历函数
printf(")");
}
}
}
void inorder(BiTree T)
{
if(T!=NULL)
{
inorder(T->lchild);
cout<<" "<<T->data;
inorder(T->rchild);
}
}
/********************************************************************
Method: SearchBST
Description:
Access: public
Returns: int
Parameter: T: the tree that will be searched, f:the father tree of the
tree that will be searched p：point to the elements
that =key, or when result =0; point to the last leaf node
********************************************************************/
void SearchBST(BiTree T,int key,BiTree f,BiTree &p,int& result)
{
result = 0;
if(T == NULL)
{
p=f;
result = 0;
}
else if(key>T->data)
{
SearchBST(T->rchild,key,T,p,result);
}
else if(key<T->data)
{
SearchBST(T->lchild,key,T,p,result);
}
else if(key == T->data)
{
p=T;
result = 1;
}
}
int InsertBST(BiTree &T,int key)
{
BiTree p,s;
int result = 0;
SearchBST(T,key,NULL,p,result);
if(result == 0) //查找不成功，插入
{
s = new BiTNode;
s->data=key;
s->lchild=s->rchild=NULL;
if(p == NULL) T=s; //被插结点*s为新的根结点
else if(key<p->data) p->lchild=s; //被插结点*s为左孩子
else p->rchild=s; //被插结点*s为右孩子
return 1; //成功插入
}
else return 0; //树中已存在关键字为e的数据元素
}
int DeleteBST(BiTree &T,int key)
{//若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点
//并返回1,否则返回0
int tmp1,tmp2;
tmp1=tmp2=0;
if(!T) return 0; //不存在关键字等于key的数据元素
else
{
if(key==T->data) {Delete(T); return 1;} //找到关键字等于key的数据元素并删除它
else if(key<T->data) tmp1=DeleteBST(T->lchild,key); //继续在左子树中删除
else tmp2=DeleteBST(T->rchild,key); //继续在右子树中删除
if(tmp1||tmp2) return 1; //在子树中删除成功，返回1
else return 0; //不存在该元素，返回0
}
}
void Delete(BiTree &p)
{//在二叉排序树中删除结点p,并重接它的左或右子树
BiTree s,q;
if(p->rchild == NULL) //右子树空，只需重接它的左子树
{
cout<<"p value"<<p->data<<endl;
q=p;
p=p->lchild;
free(q);
}
else if(p->lchild == NULL) //左子树空，只需重接它的右子树
{
cout<<"p2 value"<<p->data<<endl;
q=p;
p=p->rchild;
free(q);
}
else //左右子树均不空
{
q=p;//q一直是s的前驱，负责保存s游走后的位置
s=p->rchild;//s不断向左游走，转右，向左走到尽头
while(s->lchild)
{
q=s;s=s->lchild;
}
p->data=s->data; //q的值也被改变
cout<<"s value"<<s->data<<endl;
cout<<"q value"<<q->data<<endl;
cout<<"p value"<<p->data<<endl;
if(q!=p) q->lchild=s->rchild;
else //删除78， 左右为65,94，q没有前进过地址没变，但是值变为了94
{
q->rchild=s->lchild;
}
free(s);
}
}
void main()
{
BiTree T,p;
int ch,keyword;
char j='y';//控制程序结束与否
int temp;
printf("Creat the BST!\n");
const int n = 10;
int A[n]={53,17,78,9,45,65,94,23,81,88};
T=CreatBST(A,n);//调用建树函数建树
inorder(T);
while(j!='n')
{
printf("1.display\n");
printf("2.search\n");
printf("3.insert\n");
printf("4.delete\n");
printf("5.exit\n");
scanf(" %d",&ch); //输入操作选项
switch(ch)
{ case 1:
if(!T) printf("The BST has no elem.\n");
else {InorderBST(T);printf("\n");}//中序遍历并显示
break;
case 2:
printf("Input the keyword of elem to be searched(a number):");
scanf(" %d",&keyword); //输入要查找元素的关键字
SearchBST(T,keyword,NULL,p,temp);//查找
if(!temp) printf("%d isn't existed!\n",keyword); //没有找到
else printf("%d has been found!\n",keyword); //成功找到
break;
case 3:
printf("Input the keyword of elem to be inserted(a number):");
scanf(" %d",&keyword); //输入要插入元素的关键字
temp=InsertBST(T,keyword);//插入
if(!temp) printf("%d has been existed!\n",keyword); //该元素已经存在
else printf("Sucess to inert %d!\n",keyword); //成功插入
break;
case 4:
printf("Input the keyword of elem to be deleted(a number):");
scanf(" %d",&keyword); //输入要删除元素的关键字
temp=DeleteBST(T,keyword);//删除
InorderBST(T);
if(!temp) printf("%d isn't existed!\n",keyword); //该元素不存在
else printf("Sucess to delete %d\n",keyword); //成功删除
break;
case 5: j='n';//跳出循环，结束程序
}
}
printf("The program is over!\nPress any key to shut off the window!\n");
getchar();getchar();
}