二叉查找树(二叉排序树)的详细实现（BST）

1、序

     详细实现了二叉查找树的各种操作：插入结点、构造二叉树、删除结点、查找、  查找最大值、查找最小值、查找指定结点的前驱和后继

2、二叉查找树简介

     它或者是一棵空树；或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树

3、二叉查找树的各种操作

 

我们Windows的目录结构，其实就是树形的，一个典型的分类应用。当然除了分类，树还有别的作用，我们可以利用树建立一个非常便于查找取值又非常便于插入删除的数据结构，这就是马上要提到的二叉查找树（Binary Search Tree），这种二叉树有个特点：对任意节点而言，左子（当然了，存在的话）的值总是小于本身，而右子（存在的话）的值总是大于本身。

这种特性使得我们要查找其中的某个值都很容易，从根开始，小的往左找，大的往右找，不大不小的就是这个节点了；插入一样的道理，从根开始，小的往左，大的往右，直到叶子，就插入，算法比较简单，不一一列了，它们的时间复杂度期望为Ο(logn)。（为什么是“期望”，后面会讲）

删除则稍微麻烦点，因为我们删的不一定是叶子，如果只是叶子，那就好办，如果不是呢？我们最通常的做法就是把这个节点往下挪，直到它变为叶子为止，看图。

也许你要问，如果和左子树最大节点交换后，要删除的节点依然不是叶子，那怎么办呢？那继续呗，看图：

那左子树不存在的情况下呢？你可以查找右子树的最小节点，和上面是类似的，图我就不画了。

此处给出代码，注释非常详细，具体操作请参考代码：

    /************************************************************************* 
      这是一个二叉查找树，实现了以下操作：插入结点、构造二叉树、删除结点、查找、 
      查找最大值、查找最小值、查找指定结点的前驱和后继。上述所有操作时间复杂度 
      均为o(h),其中h是树的高度 
      注释很详细，具体内容就看代码吧 
    *************************************************************************/  
    #include "stdafx.h"  
    #include<stdio.h>  
    #include<stdlib.h>  
      
    //二叉查找树结点描述  
    typedef int KeyType;  
    typedef struct Node  
    {  
        KeyType key;          //关键字  
        struct Node * left;   //左孩子指针  
        struct Node * right;  //右孩子指针  
        struct Node * parent; //指向父节点指针                                              
    }Node,*PNode;  
      
    //往二叉查找树中插入结点  
    //插入的话，可能要改变根结点的地址，所以传的是二级指针  
    void inseart(PNode * root,KeyType key)  
    {  
        //初始化插入结点  
		//KeyType nodeArray[11]={15,6,18,3,7,17,20,2,4,13,9};
        PNode p=(PNode)malloc(sizeof(Node));  
        p->key=key;  
        p->left=p->right=p->parent=NULL;  
        //空树时，直接作为根结点  
        if((*root)==NULL){  
            *root=p;  
            return;  
        }  
        //插入到当前结点（*root）的左孩子  
        if((*root)->left == NULL && (*root)->key > key){  
            p->parent=(*root);  
            (*root)->left=p;  
            return;  
        }  
        //插入到当前结点（*root）的右孩子  
        if((*root)->right == NULL && (*root)->key < key){  
            p->parent=(*root);  
            (*root)->right=p;  
            return;  
        }  
        if((*root)->key > key)  
            inseart(&(*root)->left,key);  
        else if((*root)->key < key)  
            inseart(&(*root)->right,key);  
        else  
            return;  
    }  
      
    //查找元素,找到返回关键字的结点指针，没找到返回NULL  
    PNode search(PNode root,KeyType key)  
    {  
        if(root == NULL)  
            return NULL;  
        if(key > root->key) //查找右子树  
            return search(root->right,key);  
        else if(key < root->key) //查找左子树  
            return search(root->left,key);  
        else  
            return root;  
    }  
      
    //查找最小关键字,空树时返回NULL  
    PNode searchMin(PNode root)  
    {  
        if(root == NULL)  
            return NULL;  
        if(root->left == NULL)  
            return root;  
        else  //一直往左孩子找，直到没有左孩子的结点  
            return searchMin(root->left);  
    }  
      
    //查找最大关键字,空树时返回NULL  
    PNode searchMax(PNode root)  
    {  
        if(root == NULL)  
            return NULL;  
        if(root->right == NULL)  
            return root;  
        else  //一直往右孩子找，直到没有右孩子的结点  
            return searchMax(root->right);  
    }  
      
    //查找某个结点的前驱  
    PNode searchPredecessor(PNode p)  
    {  
        //空树  
        if(p==NULL)  
            return p;  
        //有左子树、左子树中最大的那个  
        if(p->left)  
            return searchMax(p->left);  
        //无左子树,查找某个结点的右子树遍历完了
        else{  
            if(p->parent == NULL)  
                return NULL;  
            //向上寻找前驱  
            while(p->parent){  
                if(p->parent->right == p)  
                    break;  
                p=p->parent;  
            }  
            return p->parent;  
        }  
    }  
      
    //查找某个结点的后继  
    PNode searchSuccessor(PNode p)  
    {  
        //空树  
        if(p==NULL)  
            return p;  
        //有右子树、右子树中最小的那个  
        if(p->right)  
            return searchMin(p->right);  
        //无右子树,查找某个结点的左子树遍历完了  
        else{  
            if(p->parent == NULL)  
                return NULL;  
			//向上寻找后继
			while(p->parent){ //此处要合并，不然再找根节点右子树后继时，会空指针错误，前驱查找也一样
				if(p->parent->left == p)
					break;
				p=p->parent;
			}
			return p->parent;
		}
	} 
      
    //根据关键字删除某个结点,删除成功返回1,否则返回0  
    //如果把根结点删掉，那么要改变根结点的地址，所以传二级指针  
    int deleteNode(PNode* root,KeyType key)  
    {  
        PNode q;  
        //查找到要删除的结点  
        PNode p=search(*root,key);  
        KeyType temp;    //暂存后继结点的值  
        //没查到此关键字  
        if(!p)  
            return 0;  
        //1.被删结点是叶子结点，直接删除  
        if(p->left == NULL && p->right == NULL){  
            //只有一个元素，删完之后变成一颗空树  
            if(p->parent == NULL){  
                free(p);  
                (*root)=NULL;  
            }else{  
                //删除的结点是父节点的左孩子  
                if(p->parent->left == p)  
                    p->parent->left=NULL;  
                else  //删除的结点是父节点的右孩子  
                    p->parent->right=NULL;  
                free(p);  
            }  
        }  
      
        //2.被删结点只有左子树  
        else if(p->left && !(p->right)){  
            p->left->parent=p->parent;  
            //如果删除是父结点，要改变父节点指针  
            if(p->parent == NULL)  
                *root=p->left;  
            //删除的结点是父节点的左孩子  
            else if(p->parent->left == p)  
                p->parent->left=p->left;  
            else //删除的结点是父节点的右孩子  
                p->parent->right=p->left;  
            free(p);  
        }  
        //3.被删结点只有右孩子  
        else if(p->right && !(p->left)){  
            p->right->parent=p->parent;  
            //如果删除是父结点，要改变父节点指针  
            if(p->parent == NULL)  
                *root=p->right;  
            //删除的结点是父节点的左孩子  
            else if(p->parent->left == p)  
                p->parent->left=p->right;  
            else //删除的结点是父节点的右孩子  
                p->parent->right=p->right;  
            free(p);  
        }  
        //4.被删除的结点既有左孩子，又有右孩子  
        //该结点的后继结点肯定无左子树(参考上面查找后继结点函数)  
        //删掉后继结点,后继结点的值代替该结点  
        else{  
            //找到要删除结点的后继  
            q=searchSuccessor(p);  
            temp=q->key;  
            //删除后继结点  
            deleteNode(root,q->key);  
            p->key=temp;  
        }  
        return 1;  
    }  
      
    //创建一棵二叉查找树  
    void create(PNode* root,KeyType *keyArray,int length)  
    {  
        int i;  
        //逐个结点插入二叉树中  
        for(i=0;i<length;i++)  
            inseart(root,keyArray[i]);  
    }  
      
    int main(void)  
    {  
        int i;  
        PNode root=NULL;  
        KeyType nodeArray[11]={15,6,18,3,7,17,20,2,4,13,9};  
        create(&root,nodeArray,11);  
        for(i=0;i<2;i++)  
            deleteNode(&root,nodeArray[i]);  
        printf("%d\n",searchPredecessor(root)->key);  
        printf("%d\n",searchSuccessor(root)->key);  
        printf("%d\n",searchMin(root)->key);  
        printf("%d\n",searchMax(root)->key);  
        printf("%d\n",search(root,13)->key);  
	
        return 0;  
    }