查找-二叉排序树

动态查找表：表结构本身是在查找过程中动态生成的，即对于给定值key，若表中存在其关键值等于key的记录，则查找成功返回，否则插入关键字等于key的记录。

二叉排序树或者是一颗空树，或者是具有下列性质的二叉树：

1、若他的左子树不为空，则左子树上所有结点的值均小于它的根结点的值。

2、若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

3、它的左右子树也分别为二叉排序树。

二叉排序树又称二叉查找树，根据上述定义的结构特点可见，它的查找过程与次优二叉树类似，即当二叉排序树不空时，首先将给定值和根结点的关键字比较，若相等，则查找成功，否则将根据给定值和根结点的关键字之间的大小关系，分别在左子树或右子树上继续进行查找。通常，可取二叉链表作为二叉排序树的存储结构。

首先是辅助宏的定义：

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
#define UNDERFLOW -2
#define NULL 0
#define LH 1 //左高
#define EH 0  //等高
#define RH -1 //右高
typedef int Status;
typedef int KeyType;
typedef char* InfoType;

二叉排序树的存储结构定义：

//二叉排序树的存储结构定义
typedef struct{
   KeyType key;
   InfoType otherinfo; //附加信息
}ElemType;
typedef struct BiTNode{ 
   ElemType data;
   struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
typedef BiTNode BSTNode;
typedef BiTree BSTree; 

查找（递归实现）：

算法思想：

若为空，返回NULL。

不空时，

若查找的关键字等于跟结点，返回T；

否则

    若小于根，查其左子树，返回查找结果；

    若大于根，查其右子树，返回查找结果；

BSTree SearchBST(BSTree T,KeyType key){
   /*查找（递归实现）
   若为空 返回NULL 不空时，若查找的关键字等于根结点
   返回T 否则若小于根 查其左子树 返回查找结果 若大
   于根 查其右子树 返回查找结果*/
   if(!T)
       return NULL;
   else if(T->data.key==key)   //在左子树继续查找
       return T; 
   else if(T->data.key<key)    //在右子树继续查找
       return SearchBST(T->rchild,key);
   else
       return SearchBST(T->lchild,key);
}

查找（非递归实现）:

p最初指向根结点，只要p不空且p所指结点不是所求则根据比较结果令p变为当前结点的左孩子或右孩子。

如此重复直到p空或者找到。

BSTNode *Search(BSTree T,KeyType key){
    /*查找（非递归实现）
    p指向根结点 只要p不空且p所指结点不是所求则根据比较
    结果令 p变为 当前结点的左孩子 或右孩子。如此重复则
    最终p空或者找到*/
    BSTNode *p=T;
    while(p!=NULL&&p->data.key!=key){
        if(key<p->data.key)
	     p=p->lchild;
       else
            p=p->rchild;
    }
    return p;
}

判断一颗给定二叉树是否是二叉排序树。

运用递归的思想，空树是二叉排序树；当树不空时，先判断左右子树是否是二叉排序树，只要有一个不是则原树不是二叉排序树，如果左右子树都是二叉排序树，看看左子树中最大的是否比根结点小，右子树中最小的是否比根结点大即可。

Status IsBST(BSTree &T)
{
   //判断T是否为二叉排序树
   BSTNode *p;
   if(!T)
       return TRUE;
   else
   {
       if(!IsBST(T->lchild))
           return FALSE;
       if(!IsBST(T->rchild))
	   return FALSE;
       if(T->lchild)
       {
	   //找左子树中最大的与根进行比较
	   p=T->lchild;
	   while(p&&p->rchild)
	       p=p->rchild;
	   if(p->data.key>T->data.key)
	       return FALSE;
       }
       if(T->rchild)
       {
	   //找右子树中最大的与根进行比较
	  p=T->rchild;
	  while(p&&p->lchild)
	      p=p->lchild;
	  if(p->data.key<T->data.key)
	      return FALSE;
       }
       return TRUE;
   }
}

二叉排序树的插入.

若二叉排序树为空，则插入结点应为根结点。

否则，在已有二叉排序树中查找是否存在相等结点。

若树中已有，不再插入。

若树中没有，则查找过程中必然会落空，该落空的位置就是新结点应该在的位置。

插入的过程与查找基本类似。新插入的结点一定在叶结点上。

Status InsertBST(BSTree &T,KeyType key)
{
    /*二叉排序树的插入
    若二叉排序树为空 则插入结点为根结点
    否则 在已有二叉排序树中查找是否存在相等结点
    若树中已有 不在插入
    若树中没有 则查找过程中必然会落空 该落空的位
    置就是新结点应该在的位置*/
    if(!T)
    {
        BSTNode *s;
	if(!(s=(BSTNode *)malloc(sizeof(BSTNode))))
           exit(OVERFLOW);
	s->data.key=key;
	s->lchild=s->rchild=NULL;
	T=s;
	return OK;
   }
   else if(key==T->data.key)
       return ERROR;
   else if(key<T->data.key)
       return InsertBST(T->lchild,key);
   else
       return InsertBST(T->rchild,key);
}

二叉排序树的创建：

从空树出发，依次按照结点插入方法插入各结点。

Status CreateBST(BSTree &T)
{  
    //二叉排序树的创建
    //从空树出发，依次按照结点插入方法插入各结点即可
    T=NULL;
    KeyType key;
    scanf("%d",&key);
    while(key)
    {
       if(InsertBST(T,key))
           scanf("%d",&key);
       else
	   return ERROR;
    }
    return OK;
}

二叉排序树的删除：

首先定位被删除的结点及其双亲，如果不存在关键字等于key的结点，则直接返回。

否则，根据被删结点特性分类处理，保证删除后仍是二叉排序树。

1、被删除的结点是叶子结点。若有双亲则将双亲结点中相应指针域的值置空，否则T置空。

2、被删结点只有左子树或右子树。双亲结点相应指针指向被删结点的唯一子树。

3、被删结点既有左子树也有右子树。找左子树最大的元素代替被删除元素，归结为前一情况。

void DeleteBFT(BSTree &T,KeyType key)
{
   /*二叉排序树的删除
   首先定位被删除的结点及其双亲
   如果不存在关键字等于key的结点则直接返回
   否则 根据被删除结点特性分类处理 保证删后
   仍是二叉排序树 
   被删除的是叶子结点 若有双亲 则将双亲结点中相
   应指针域的值置空 否则T置空
   被删的结点只有左子树或右子树 双亲结点相应指针
   域指向被删结点的唯一子树
   被删结点既有左子树也有右子树 找左子树中最大的
   代替删除元素
   */
   BSTNode *p=T,*f=NULL,*q;
   while(p&&p->data.key!=key)
   {
       if(key<p->data.key)
       {
           f=p;
	   p=p->lchild;
       } 
       else
       {
	   f=p;
           p=p->rchild;
       }
   }
   if(!p)
       return;
   if(!p->lchild&&!p->rchild)
   {
       if(!f)
       {
           free(p);
	   T=NULL;
           p=NULL;
       }
       else if(f->lchild==p)
	   f->lchild=NULL;
       else
	   f->rchild=NULL;
       free(p);
       p=NULL;
   }
   else if(!p->lchild)
   {
       if(!f)
           T=p->rchild;
       else if(f->lchild==p)
           f->lchild=p->rchild;
       else
           f->rchild=p->rchild;
       free(p);
       p=NULL;
   }
   else if(!p->rchild)
   {
       if(!f)
           T=p->lchild;
       else if(f->lchild==p)
           f->lchild=p->lchild;
       else
           f->rchild=p->lchild;
       free(p);
       p=NULL;
   }
   else
   {
       f=p;  //f始终指向q的双亲 方便后面的删除
       q=p->lchild; 
       while(q->rchild)  //q定位最大 f指向其双亲
       {
          f=q;
	  q=q->rchild;
       }
       p->data.key=q->data.key; //左子树最大者的值填充到原本被删结点
       if(f->lchild==q) //删除左子树中最大者
           f->lchild=q->lchild;
       else
           f->rchild=q->lchild;
       free(q);
       q=NULL;
    }
}

二叉排序树查找的性能分析:

平均查找长度和二叉树的形态有关，即，

最好 logN。形态均匀，与二分查找的判定树相似。

最坏：(n+1)/2