二叉搜索树的基本操作(C代码实现)

对于一棵有n个节点的完全二叉搜索树的 基本操作可以实现在O(lgn)的时间内，通常一棵随机建立的二叉搜索树的期望也可以达到O(lgn)。对二叉搜索树来说更有意义的数据是它的高度h，因为以下的操作时间复杂度可以描述为O(h)

这里实现的基本操作有：Search(查找节点), Minimum(最小值), Maximum(最大值), Predecessor(前驱), Successor(后继), Insert(插入节点), Delete(删除节点)。

 他们可以比较高效地实现一个动态集合(dynamic-set)。

根据二叉搜索树的定义理解这些基本操作的算法并不难。

// 二叉搜索树基本操作演示 by DaNmarner 2006 7
#include  < stdio.h >

typedef  struct  BTType
... {
        struct BTType *lch,*rch,*p;
        int data;
}  BTNODE;
typedef BTNODE  *  BITREE;

BITREE BST_Maximum(BITREE x);
BITREE BST_Search (BITREE x, int  a);
BITREE BST_Minimum(BITREE x);
BITREE BST_Successor(BITREE x);
BITREE BST_Predecessor(BITREE x);
void  BST_Insert(BITREE  * x,BITREE t);
void  BST_Delete(BITREE y);
void  InorderTreeWalk (BITREE t);
BITREE Creat( int  d);

int  main ( void )
... {
        BITREE root=NULL;

        printf("Displaying Binary Search Tree Operations by DaNmarner 2006 ");
        BST_Insert(&root,Creat(343));
        BST_Insert(&root,Creat(3423));
        BST_Insert(&root,Creat(34233));
        BST_Insert(&root,Creat(34));
        BST_Insert(&root,Creat(3));
        printf("Inorder Tree Walk [ ");
        InorderTreeWalk(root);
        printf("] ");
        printf("The prodecessor of data 343 is: %d ",
                BST_Predecessor(BST_Search(root,343))->data);
        printf("The successor of data 343 is: %d ",
                BST_Successor(BST_Search(root,343))->data);
        printf("Maximum of the binary search tree is: %d ",
                BST_Maximum(root)->data);
        printf("Minimum of the binary search tree is: %d ",
                BST_Minimum(root)->data);
        BST_Delete(BST_Search(root,343));
        printf("Inorder Tree Walk after deleting data 343:[ ");
        InorderTreeWalk(root);
        printf("] ");
        system("pause");
        return 0;
}

void  InorderTreeWalk (BITREE t)  // 中序遍历二叉树
... {
        if (t!=NULL) ...{
                InorderTreeWalk(t->lch);
                printf("%d ",t->data);
                InorderTreeWalk(t->rch);
        }
}
BITREE BST_Search (BITREE x, int  a)  // 搜索数据为a的节点
... {
        while (x!=NULL && x->data!=a) x=(a<x->data)?x->lch:x->rch; 
        return x;
}

BITREE BST_Maximum(BITREE x)  // 求最大值所在节点
... {
        while (x->rch!=NULL) x=x->rch; 
        return x;
}

BITREE BST_Minimum(BITREE x)  // 求最小值所在节点
... {
        while (x->lch!=NULL) x=x->lch; 
        return x;
}

BITREE BST_Successor(BITREE x)  // 求节点x的后继
... {
        if (x->rch != NULL) return BST_Minimum(x->rch);
        else ...{
                BITREE y=x->p;
                while (y!=NULL && x==y->rch)...{
                        x=y;
                        y=y->p;
                }
        return y;
        }
}

BITREE BST_Predecessor(BITREE x)  // 求节点x的前驱
... {
        if (x->lch != NULL) return BST_Maximum(x->lch);
        else ...{
                BITREE y=x->p;
                while (y!=NULL && x==y->lch)...{
                        x=y;
                        y=y->p;
                }
                return y;
        }
}

void  BST_Insert(BITREE  * x,BITREE t)  // 在二叉树x中插入节点t
... {
        BITREE y=NULL,p=*x;
        while (p!=NULL)
        ...{
                y=p;
                p=(t->data<p->data)?p->lch:p->rch;
        }
        if(y==NULL) *x=t;
        else ...{
                if (t->data<y->data) y->lch=t;
                else y->rch=t;
                t->p=y;
        }
}

void  BST_Delete(BITREE y)  // 删除节点y
... {
        if (y->lch==NULL && y->rch==NULL && y->p) ...{
                if(y==(y->p)->lch) (y->p)->lch=NULL;
                else (y->p)->rch=NULL;
        }else if (y->rch==NULL && y->p) ...{
                if(y==y->p->lch) y->p->lch=y->lch;
                else y->p->rch=y->lch;
        }else if (y->lch==NULL && y->p) ...{
                if(y==y->p->lch) y->p->lch=y->rch;
                else y->p->rch=y->rch;
        }else ...{
                BITREE t=BST_Successor(y);
                y->data=t->data;
                BST_Delete(t);
                y=t;
        }
        free(y);
}

BITREE Creat( int  d)   // 建立节点
... {
        BITREE tmp = (BITREE)malloc(sizeof(BTNODE));
        tmp->data = d;
        tmp->p=tmp->lch=tmp->rch = NULL;
        return tmp;
}

参考书：算法导论。