二叉搜索树（Binary Search Tree）--C语言描述(转)

图解二叉搜索树概念

二叉树呢，其实就是链表的一个二维形式，而二叉搜索树，就是一种特殊的二叉树，这种二叉树有个特点：对任意节点而言，左孩子（当然了，存在的话）的值总是小于本身，而右孩子（存在的话）的值总是大于本身。

下面来介绍在此种二叉树结构上的查找，插入，删除算法思路。

查找：因为这种结构就是为了来方便查找的，所以查找其中的某个值很容易，从根开始，小的往左找，大的往右找，不大不小的就是这个节点了；

代码很简单，这里就不写了。

插入：插入一样的道理，从根开始，小的往左，大的往右，直到叶子，就插入。

代码：

int Insert(BSTree *T,data_type data)//插入数据
{
    BSTree newnode,p;
    newnode = (BSTree)malloc(sizeof(BSNode));
    newnode->lchild = newnode->rchild = NULL;
    newnode->data = data;
    if(*T == NULL)
    {
        *T = newnode;
    }
    else
    {
        p = *T;
        while(1)
        {
            if(data == p->data)
            {
                return 0;//数值已存在，不能插入
            }
            else if(data > p->data)
            {
                if(p->rchild == NULL)//右孩子为空，插入
                {
                    p->rchild = newnode;
                    return 1;
                }
                else        //继续向下找
                {
                    p = p->rchild;
                }
            }
            else
            {
                if(p->lchild == NULL)//左孩子为空，插入
                {
                    p->lchild = newnode;
                    return 1;
                }
                else        //继续向下找
                {
                    p = p->lchild;
                }
            }
        }
    }
}

删除：而结点的删除则比较麻烦，是这个结构中最难的一环，因为我们删除的结点不一定是叶子结点，是叶子结点很好办，但是如果是二叉树中的一个结点，则涉及到删除后的连接问题。

删除一共分为以下四种情况：

1.删除结点为叶子结点：这个就不说了，删除很简单。

2.删除结点不是叶子结点，其左子树不为空，右子树为空：这种情况，只需将其父结点与其右孩子结点连接，然后删除，例如删除下图的40，就是连接30与35。

3.删除结点不是叶子结点，其右子树不为空，左子树为空：这种情况，只需将其父结点与其左孩子结点连接，然后删除，例如删除下图的80，就是连接50和90

4.删除结点不是叶子结点，左右子树都不为空，这种情况最复杂，咋们单独分析分析。

此种情况下，总的删除思想就是：把这个结点往下挪，直到它变为叶子为止。挪移规则：即和此结点下的最大孩子的值交换，把删除该结点转换为删除孩子结点的操作。

当然会出现这种情况，交换后此结点仍然不是叶子结点，那就继续按照挪移规则直到将改结点挪移成叶子结点。举例如图：

首先是我自己写的一个删除算法，借用了查找函数。

我的想法还是以前链表的删除思路，删除一个结点需要记录前一个结点，所以我就是用fa记录删除结点的父结点，然后操作的。

所以借用的查找函数就不仅仅只是返回结点地址，也要返回父结点地址。

BSTree Find(BSTree T,data_type data,BSTree *target) //查找函数,并返回父亲结点地址
{
    if(T == NULL)//二叉树为空
    {
        *target = NULL;
        return NULL;
    }
    else if(T->data == data)//树根即为要查找的结点
    {
        *target = T;
        return NULL;
    }
    else
    {
        while(T)
        {
            if(T->lchild && T->lchild->data == data)
            {
                *target = T->lchild;
                return T;
            }
            if(T->rchild && T->rchild->data == data)
            {
                *target = T->rchild;
                return T;
            }
            if(data > T->data)
            {
                T = T->rchild;
            }
            if(data < T->data)
            {
                T = T->lchild;
            }
        }
        return NULL;
    }
}

int Delete1(BSTree *T,data_type data)//删除
{
    BSTree fa,target;
    if(*T == NULL)//树为空
    {
        return 0;
    }
    fa = Find(*T,data,&target);//fa为删除结点的父结点，target为删除结点
    if(target->lchild == NULL)    //删除结点左子树为空，右子树不为空的情况(左右子树都为空的情况也适用)
    {
        if(fa == NULL && target->rchild == NULL)//树只存在根结点的情况
        {
            free(*T);
            *T = NULL;
            return 1;
        }
        if(fa->rchild == target)
        {
            fa->rchild = target->rchild;
            free(target);
            return 1;
        }
        if(fa->lchild == target)
        {
            fa->lchild = target->rchild;
            free(target);
            return 1;
        }
    }
    else if(target->rchild == NULL)//删除结点右子树为空，左子树不为空的情况
    {
        if(fa->rchild == target)
        {
            fa->rchild = target->lchild;
            free(target);
            return 1;
        }
        if(fa->lchild == target)
        {
            fa->lchild = target->lchild;
            free(target);
            return 1;
        }
    }
    else    //左右子树都不为空的情况
    {
        if(target->lchild->rchild == NULL)    //孩子结点中最大值结点为target->lchild
        {
            target->data = target->lchild->data;
            return Delete1(&(target->lchild),target->data);
        }
        else        //孩子结点中最大值结点为target->lchild->rchild.....->rchild
        {
            BSTree p1,p2;
            p2 = target->lchild;
            p1 = p2->rchild;
            while(p1->rchild != NULL)//循环找到最大值结点
            {
                p2 = p1;
                p1 = p1->rchild;
            }
            target->data = p1->data;
            return Delete1(&(p2->rchild),p1->data);
        }
    }
}

然后写完之后感觉自己的算法篇幅好大，貌似有点麻烦，于是在网上找了一下相关的二叉搜索树的删除算法，发现一个很精妙小巧的算法，将递归用的非常漂亮。

当然，算法思路都是差不多的，所以效率上应该没有什么很大的差别，不过这个算法递归思想用的很赞，值得学习一下。

建议先把上面我写的算法看明白了，在看下面的这个。

//a：删除叶子结点，只要将其双亲结点链接到它的指针置空即可。
//b：删除单支结点，只要将其后继指针链接到它所在的链接位置即可
//c：删除双支结点，一般采用的方法是首先把它的中序前驱结点的值赋给该结点的值域，
//然后再删除它的中序前驱结点，若它的中序前驱结点还是双支结点，继续对其做同样的操作，
//若是叶子结点或单支结点则做对应的操作，若是根结点则结束。

int Delete(BSTree *T,data_type data)
{
    BSTree temp;
    if(data < (*T)->data)//继续在左子树中查找
    {
        return Delete(&(*T)->lchild,data);
    }
    if(data > (*T)->data)//继续在右子树中查找
    {
        return Delete(&(*T)->rchild,data);
    }
    //代码运行到此处，则找到data,即为(*T)->data
    temp = *T;//*T：删除结点地址，T:记录删除结点地址的指针，即为删除结点的父结点的左/右指针
    if((*T)->lchild == NULL)//删除结点的左子树为空，将整个右子树作为树根(此处也包含叶子结点情况)
    {
        (*T) = (*T)->rchild;
        free(temp);
        return 1;
    }
    else if((*T)->rchild == NULL)//删除结点的右子树为空，将整个左子树作为树根
    {
        (*T) = (*T)->lchild;
        free(temp);
        return 1;
    }
    else//删除结点的左右子树都不为空，找左子树的的最大值结点
    {
        if((*T)->lchild->rchild == NULL)//最大值结点为左孩子的情况
        {
            (*T)->data = (*T)->lchild->data;
            Delete(&((*T)->lchild),(*T)->data);
        }
        else        //最大值结点为最深的右孩子结点情况
        {
            BSTree p1,p2;
            p2 = (*T)->lchild;
            p1 = p2->rchild;
            while(p1->rchild != NULL)
            {
                p2 = p1;
                p1 = p1->rchild;
            }
            (*T)->data = p1->data;
            Delete(&(p2->rchild),p1->data);
        }
    }
}

二：二叉搜索树完整代码（C语言）

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

typedef int data_type;

typedef struct bst
{
    data_type data;
    struct bst *lchild,*rchild;
}BSNode,*BSTree;

BSTree Find(BSTree T,data_type data,BSTree *target) //查找函数,并返回父亲结点地址
{
    if(T == NULL)//二叉树为空
    {
        *target = NULL;
        return NULL;
    }
    else if(T->data == data)//树根即为要查找的结点
    {
        *target = T;
        return NULL;
    }
    else
    {
        while(T)
        {
            if(T->lchild && T->lchild->data == data)
            {
                *target = T->lchild;
                return T;
            }
            if(T->rchild && T->rchild->data == data)
            {
                *target = T->rchild;
                return T;
            }
            if(data > T->data)
            {
                T = T->rchild;
            }
            if(data < T->data)
            {
                T = T->lchild;
            }
        }
        return NULL;
    }
}

int Insert(BSTree *T,data_type data)//插入数据
{
    BSTree newnode,p;
    newnode = (BSTree)malloc(sizeof(BSNode));
    newnode->lchild = newnode->rchild = NULL;
    newnode->data = data;
    if(*T == NULL)
    {
        *T = newnode;
    }
    else
    {
        p = *T;
        while(1)
        {
            if(data == p->data)
            {
                return 0;//数值已存在，不能插入
            }
            else if(data > p->data)
            {
                if(p->rchild == NULL)//右孩子为空，插入
                {
                    p->rchild = newnode;
                    return 1;
                }
                else        //继续向下找
                {
                    p = p->rchild;
                }
            }
            else
            {
                if(p->lchild == NULL)//左孩子为空，插入
                {
                    p->lchild = newnode;
                    return 1;
                }
                else        //继续向下找
                {
                    p = p->lchild;
                }
            }
        }
    }
}

int Delete1(BSTree *T,data_type data)//删除
{
    BSTree fa,target;
    if(*T == NULL)//树为空
    {
        return 0;
    }
    fa = Find(*T,data,&target);//fa为删除结点的父结点，target为删除结点
    if(target->lchild == NULL)    //删除结点左子树为空，右子树不为空的情况(左右子树都为空的情况也适用)
    {
        if(fa == NULL && target->rchild == NULL)//树只存在根结点的情况
        {
            free(*T);
            *T = NULL;
            return 1;
        }
        if(fa->rchild == target)
        {
            fa->rchild = target->rchild;
            free(target);
            return 1;
        }
        if(fa->lchild == target)
        {
            fa->lchild = target->rchild;
            free(target);
            return 1;
        }
    }
    else if(target->rchild == NULL)//删除结点右子树为空，左子树不为空的情况
    {
        if(fa->rchild == target)
        {
            fa->rchild = target->lchild;
            free(target);
            return 1;
        }
        if(fa->lchild == target)
        {
            fa->lchild = target->lchild;
            free(target);
            return 1;
        }
    }
    else    //左右子树都不为空的情况
    {
        if(target->lchild->rchild == NULL)    //孩子结点中最大值结点为target->lchild
        {
            target->data = target->lchild->data;
            return Delete1(&(target->lchild),target->data);
        }
        else        //孩子结点中最大值结点为target->lchild->rchild.....->rchild
        {
            BSTree p1,p2;
            p2 = target->lchild;
            p1 = p2->rchild;
            while(p1->rchild != NULL)//循环找到最大值结点
            {
                p2 = p1;
                p1 = p1->rchild;
            }
            target->data = p1->data;
            return Delete1(&(p2->rchild),p1->data);
        }
    }
}

//a：删除叶子结点，只要将其双亲结点链接到它的指针置空即可。
//b：删除单支结点，只要将其后继指针链接到它所在的链接位置即可
//c：删除双支结点，一般采用的方法是首先把它的中序前驱结点的值赋给该结点的值域，
//然后再删除它的中序前驱结点，若它的中序前驱结点还是双支结点，继续对其做同样的操作，
//若是叶子结点或单支结点则做对应的操作，若是根结点则结束。

int Delete(BSTree *T,data_type data)
{
    BSTree temp;
    if(data < (*T)->data)//继续在左子树中查找
    {
        return Delete(&(*T)->lchild,data);
    }
    if(data > (*T)->data)//继续在右子树中查找
    {
        return Delete(&(*T)->rchild,data);
    }
    //代码运行到此处，则找到data,即为(*T)->data
    temp = *T;//*T：删除结点地址，T:记录删除结点地址的指针，即为删除结点的父结点的左/右指针
    if((*T)->lchild == NULL)//删除结点的左子树为空，将整个右子树作为树根(此处也包含叶子结点情况)
    {
        (*T) = (*T)->rchild;
        free(temp);
        return 1;
    }
    else if((*T)->rchild == NULL)//删除结点的右子树为空，将整个左子树作为树根
    {
        (*T) = (*T)->lchild;
        free(temp);
        return 1;
    }
    else//删除结点的左右子树都不为空，找左子树的的最大值结点
    {
        if((*T)->lchild->rchild == NULL)//最大值结点为左孩子的情况
        {
            (*T)->data = (*T)->lchild->data;
            Delete(&((*T)->lchild),(*T)->data);
        }
        else        //最大值结点为最深的右孩子结点情况
        {
            BSTree p1,p2;
            p2 = (*T)->lchild;
            p1 = p2->rchild;
            while(p1->rchild != NULL)
            {
                p2 = p1;
                p1 = p1->rchild;
            }
            (*T)->data = p1->data;
            Delete(&(p2->rchild),p1->data);
        }
    }
}

void CreateBSTree(BSTree *T)//创建二叉树，调用插入算法创建
{
    data_type data;
    char ch;
    printf("请输入要创建的二叉搜索树的数据(数据之间用空格隔开,输入完毕按回车)：");
    do
    {
        scanf("%d",&data);
        ch = getchar();
        Insert(T,data);
    }
    while (ch != 10);
}

void Inorder(BSTree T)
{
    if(T)
    {
        Inorder(T->lchild);
        printf("%d ",T->data);
        Inorder(T->rchild);
    }
}

int main()
{
    BSTree T,fa,target;
    T = NULL;
    CreateBSTree(&T);
    Inorder(T);
    int select;
    data_type data;
    while(1)
    {
        printf("1.插入  2.删除 3.中序遍历\n");
        scanf("%d",&select);
        if(select == 1)
        {
            printf("请输入要插入的数据：");
            scanf("%d",&data);
            Insert(&T,data);
            Inorder(T);
            getch();
        }
        else if(select == 2)
        {
            printf("删除数据：");
            scanf("%d",&data);
            Delete1(&T,data);
            Inorder(T);
            getch();
        }
        else if(select == 3)
        {
            Inorder(T);
            getch();
        }
    }
    return 0;
}
/* 50 30 80 20 40 90 35 85 32 88*/

 

http://www.cnblogs.com/ecizep/p/4778241.html