码迷，mamicode.com
首页 > 编程语言 > 详细

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

时间：2015-09-02 13:12:32      阅读：278      评论：0      收藏：0      [点我收藏+]

标签：

一：硬着头皮就是上

数据结构中有个东西一直不愿意去面对，就是二叉搜索树，以及平衡二叉树。想想就耗脑细胞

马上开学了，就要学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*/

 

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

标签：

原文地址：http://www.cnblogs.com/ecizep/p/4778241.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！