数据结构与算法分析--二叉排序树（二叉查找树，二叉搜索树）的查找、插入和删除操作

什么是二叉排序树

它表示一棵二叉树，并且包含以下性质：

1）可能是一棵空树

2）若不为空，那么其左子树结点的值都是小于根结点的值，右子树结点的值都是大于根结点的值

3）左右子树都是二叉树。

对于二叉排序树功能的介绍

本文主要介绍的是二叉排序树的几种基本操作，包括查找、插入和删除操作。用到的二叉排序树如下图所示：



二叉排序树的建立

二叉树结点的创建：

typedef struct BiTNode
{
int data;
struct BiTNode *lchild,*rchild,*parent;
}BiTNode,*BiTree;

二叉排序树的创建过程

二叉排序树的创建过程。主要包含两个部分：二叉排序树的创建和插入每个结点的过程。主要就是利用递归操作插入结点。具体过程如下：

申请一个结点p的空间，存储数据和左右子树的指针。

几种情况的判断：

1.判断是否为空树，空树时，插入的节点直接为根结点

2.插入结点的值>根结点的值，插入结点直接设置为右孩子。设置方式：根结点的右孩子子针直接连接插入结点。

3.插入结点的值<根结点的值，插入结点直接设置为左孩子。设置方式 : 根结点的左孩子子针直接连接插入结点。

4.进行递归操作。继续插入下个结点，此时的根结点就是刚刚插入的结点。

//创建一棵二叉排序树
void create(BiTree* root,int* keyArray,int length )
{
int i;
for(i=0;i<length;i++)
insert(root,keyArray[i]);
}
//插入每个结点
void insert(BiTree* root,int data)
{
//初始化插入的节点
BiTree p=(BiTree)malloc(sizeof(BiTNode));
p->data=data;
p->lchild=p->rchild=NULL;
//空树时，直接最为根结点
if((*root)=NULL)
{
*root=p;
return;
}
//插入到当前结点的左孩子
if((*root)->lchild==NULL&&(*root)->data>data)
{
p->parent=(*root);
(*root)->lchild=p;
return;
}
if((*root)->rchild==NULL&&(*root)->data<data)
{
p->parent=(*root);
(*root)->rchild=p;
return;
}
if((*root)->data>data)
insert(&(*root)->lchild,data);
else if((*root)->data<data)
insert(&(*root)->rchild,data);
else
return;
}

-二叉排序树的搜索和插入操作

二叉排序树的搜索过程：

二叉树是否存在

搜索结点的值是否等于T的值

如果搜索结点的值小于T的值，那就进行递归操作继续搜索T的左子树。

如果搜索结点的值大于T的值，那就进行递归操作继续搜索T的右子树。

二叉排序树的插入操作主要包括以下几个过程：

1.首先判断插入结点，和树中结点是否存在重复，这时候用到的是结点的搜索操作，若没有重复的节点，就进行后面的插入操作。

2.创建一个新结点，存储插入结点的值。

3.如果是空树，插入结点直接插入进去。

4.如果树不为空，插入结点的值小于最后一个结点的值，插入结点连接最后一个结点的左子树；插入结点的值大于最后一个结点的值，插入结点连接最后一个结点的右子树。

/*
当二叉排序树T中不存在关键字key的数据元素时，插入key并返回true，否则返回false.
*/
BiTree SearchBST(BiTree T,int key,BiTree f,BiTree * p)
{
if(!T)
{
*p=f;
return NULL;
}
else if(key==T->data)
{
*p=T;
return *p;
}
else if(key<T->data)
{
return SearchBST(T->lchild,key,T,p);
}
else
return SearchBST(T->rchild,key,T,p);
}
BiTree InsertBTS(BiTree *T ,int key)
{
BiTree p,s;
//判断经过二叉树的查找，是否找得到所需结点
if(!SearchBST(*T,key,NULL,&p))
{
//找不到结点，那首先生成一个结点（不存在重复结点）
s=(BiTree)malloc(sizeof(BiTNode));
s->data=key;
s->lchild=NULL;
s->rchild=NULL;

if(!p)//最后一个结点是否在树里面，进入循环表示树不为空，进入查找。
{
*T=s;
}
if(key<p->data)
{
s=p->lchild;
}
else
{
s=p->rchild;
}
return s;
}
else
{
return NULL;
}

}

.

查找删除结点操作

判断键值是否等于当前结点的值，等于直接调用删除函数。

如果键值小于当前结点的值，则递归调用查找删除结点，若值小于此结点的值，递归传入左子树，若大于递归传入右子树。

删除操作主要包含三种情况：

定义删除结点为p结点，q指针用于传递。

删除结点的右子树为空的情况下

把p结点的地址传给q指针，再把p的左子树的值传递给p，最后释放q。

删除结点的左子树为空的情况下

把p结点的地址传给q指针，再把p的右子树的值传递给p，最后释放q。

删除结点的左右子树都不为空

这种情况的主要思想是用删除结点的直接前驱去替换这个结点的值，最后只需要释放直接前驱的结点即可，框架结构是不需要调整的。（下面的删除方式是以找到左子树的直接前驱结点为例）

1.q指针指向删除结点的位置，s指针指向删除结点的左子树。

2.然后循环搜索直接前驱结点，并用s指针指向这个前驱结点，q指向前驱结点的双亲节点。

3.进行判断，如果删除的结点就是前驱结点的双亲节点，那么直接就把双亲节点替换到前驱结点的位置。如把99替换到100的位置。如果存在前驱结点的子树，那么就把删除结点的左子树连接前驱结点的左子树。例如103放到100的位置上。

4。最后释放前驱结点。

BiTree Delete(BiTree *p)
{
BiTree q,s;
//右子树为空的情况下
if((*p)->rchild==NULL)
{
q=*p;
*p=(*p)->lchild;
free(q);
}
else if((*p)->lchild==NULL)
{
q=*p;
*p=(*p)->rchild;
free(q);
}
//以直接前驱做替换
else
{
q=*p;
s=(*p)->lchild;
while(s->rchild)
{
q=s;
s=s->rchild;
}
(*p)->data=s->data;
if(q!=*p)
{
q->rchild=s->lchild;
}
else
{
q->lchild=s->lchild;
}
free(s);
}
return s;
}

//删除二叉树模块
BiTree DeleteBST(BiTree *T ,int key)
{
if(!*T)
{
return NULL;
}
else
{
if(key==(*T)->data)
return Delete(T);

else if(key<(*T)->data)
{
return DeleteBST(&((*T)->lchild),key);
}
else
{
return DeleteBST(&(*T)->rchild,key);
}
}
}