二叉排序树详解及其C语言简单实现

最新推荐文章于 2023-08-31 20:33:08 发布
最新推荐文章于 2023-08-31 20:33:08 发布
阅读量2k 收藏 15
点赞数 2
分类专栏： 数据结构与算法 文章标签： c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52668274/article/details/127578236
版权

定义

  二叉排序树（Binary Sort Tree）又称二叉查找树（Binary Search Tree），也称为二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列特点的二叉树：

1. 若左子树不空，其左子树上所有结点的值均小于它的根结点的值；
2. 若右子树不空，则右子树上所有结点的值均大于它的根结点的值；
3. 结点的左、右子树也分别是一个二叉排序树.

如下为一个典型的二叉搜索树：
在这里插入图片描述

二叉排序树的基本操作

1 二叉树的构建

  目前含有如下元素 23， 19， 29， 16， 21， 32， 20，其构建流程为：

1  首先插入元素23；
2  元素19小于元素23，根据规则将19插入23的左子树中；
3  元素29大于元素23，根据规则将29插入23的右子树中；
4  元素16小于元素19，根据规则将16插入19的左子树中；
5  元素21大于元素19小于元素23，根据规则将21插入19的右子树中；
6  元素32大于元素29，根据规则将32插入29的右子树中；
7  元素20大于元素19小于元素21，根据规则将20插入21的左子树中；

在这里插入图片描述

2 二叉搜索树的查找操作

例：从上述二叉搜索树查找元素 21，流程如下：23 --> 19 --> 21

1  首先与根节点进行比较，21 小于 23，可知应在其左子树中进行查找；
2  元素19小于元素21，根据规则应在元素19的右子树中进行查找；
3  元素21大于元素21，成功查找到，结束。

在这里插入图片描述

3 二叉搜索树的插入操作

向上述二叉搜索树中插入元素 22，流程如下【首先找到插入位点，插入位点为叶子结点的指针域中，后修改父节点的指针域】：

1  根据查找规则找到插入位点，即插入位点为元素 21的右子树中；
2  将元素21 的右指针域指向元素 22。
在这里插入图片描述

4 二叉搜索树的删除操作
4.1 删除元素为叶子结点，无左右子树(看图更明了)

在这里插入图片描述

4.2 删除元素非叶子结点，但含有子左右子树中的一个(看图更明了)

在这里插入图片描述

4.3 删除元素为非叶子结点，同时含有左右子树，该情况稍复杂

1  根据查找规则找到删除元素；
2  确定右子树，找到右子树中的最小值元素 xmin。
3  将待删除元素与xmin互换位置，更新对应的指针域信息
在这里插入图片描述

源代码实现

binary_sort_tree.h

#ifndef BINARY_SORT_TREE_H
#define BINARY_SORT_TREE_H

typedef int Elemtype;

typedef enum
{
    TRUE,
    FALSE,
    NON_ALLOCATED
} Status;

typedef struct BSNode{
    Elemtype item;
    struct BSNode *lchild;
    struct BSNode *rchild;
} BSNode;

typedef struct BStree{
    BSNode *root;
    int size;
} BSTree;


void InitBSTree(BSTree *ptree);
Status BSTreeIsFull(const BSTree *ptree);
Status BSTreeIsEmpty(const BSTree *ptree);
Status BSTreeSearch(const BSTree *ptree, Elemtype key);
Status BSTreeInsert(BSTree *ptree, Elemtype key);
Status BSTreeDelete(BSTree *ptree, Elemtype key);
int BSTreeDepth(const BSTree *ptree);
void InorderShowBSTree(const BSTree *ptree);
void PostShowBSTree(const BSTree *ptree);
void DeleteAll(BSTree *ptree);

#endif //BINARY_SORT_TREE_H

#include <stdio.h>
#include <stdlib.h>
typedef struct pair
{
    BSNode *parent;
    BSNode *child;
} pair;

static BSNode *MakeNode(const Elemtype key);
static void AddNode(BSNode *newnode, BSNode *root);
static void DeleteNode(BSNode **delnode);
static pair Seek(const BSTree *ptree, Elemtype key);
static void traverse(BSNode *root);
static void DeleteAllNode(BSNode *root);

void InitBSTree(BSTree *ptree)
{

    ptree->root = NULL;
    ptree->size = 0;
}

Status BSTreeIsFull(const BSTree *ptree)
{
    BSNode *tmp = (BSNode *)malloc(sizeof(BSNode));
    if (tmp == NULL)
        return TRUE;

    else
        return FALSE;
}

Status BSTreeIsEmpty(const BSTree *ptree)
{
    if (ptree->size == 0)
        return TRUE;
    else
        return FALSE;
}

Status BSTreeSearch(const BSTree *ptree, Elemtype key)
{
    return (Seek(ptree, key).child == NULL ? FALSE : TRUE);
}

Status BSTreeInsert(BSTree *ptree, Elemtype key)
{
    BSNode *newnode;

    if (Seek(ptree, key).child != NULL)
    {
        printf("erroe, do not insert same elemnt of BSTree\n");
        return FALSE;
    }

    newnode = MakeNode(key);
    if (newnode == NULL)
    {
        printf("error, can not create a BSNode since out of memory!\n");
        return FALSE;
    }

    if(ptree->root == NULL)
        ptree->root = newnode;
    
    else
        AddNode(newnode, ptree->root);

    ptree->size++;

    return TRUE;
}

Status BSTreeDelete(BSTree *ptree, Elemtype key)
{
    pair look;
    if (!BSTreeIsEmpty(ptree))
    {
        printf("BSTree is empty!!!\n");
        return FALSE;
    }

    look = Seek(ptree, key);

    if (look.child == NULL)
    {
        printf("delete element is not exist!\n");
        return FALSE;
    }

    else if (look.parent == NULL)
    {
        DeleteNode(&look.parent);
    }

    else if (look.parent->lchild == look.child)
        DeleteNode(&look.parent->lchild);

    else if (look.parent->rchild == look.child)
        DeleteNode(&look.parent->rchild);

    ptree->size--;

    return TRUE;
}

void InorderShowBSTree(const BSTree *ptree)
{
    if (ptree != NULL)
        traverse(ptree->root);
    printf("\n");
}

static BSNode *MakeNode(const Elemtype key)
{
    BSNode *new_node = (BSNode *)malloc(sizeof(BSNode));

    if (new_node != NULL)
    {
        new_node->item = key;
        new_node->lchild = NULL;
        new_node->rchild = NULL;
    }
    return new_node;
}

static void traverse(BSNode *root)
{
    if (root == NULL)
        return;

    traverse(root->lchild);
    printf("%d\t", root->item);
    traverse(root->rchild);
}

void FreeBSTree(BSTree *ptree)
{
    if (ptree != NULL)
        DeleteAllNode(ptree->root);

    ptree->size = 0;
    ptree->root = NULL;
}

static pair Seek(const BSTree *ptree, Elemtype key)
{
    pair look;
    look.parent = NULL;
    look.child = ptree->root;

    if (look.child == NULL)
        return look;

    while (look.child != NULL)
    {
        if (key < look.child->item)
        {
            look.parent = look.child;
            look.child = look.child->lchild;
        }

        else if (key > look.child->item)
        {
            look.parent = look.child;
            look.child = look.child->rchild;
        }
        else
        {
            break;
        }
    }
    return look;
}

static void AddNode(BSNode *newnode, BSNode *root)
{
    if (root->item > newnode->item)
    {
        if (root->lchild == NULL)
            root->lchild = newnode;
        else
        {
            AddNode(newnode, root->lchild);
        }
    }

    else if (root->item < newnode->item)
    {
        if (root->rchild == NULL)
            root->rchild = newnode;
        else
            AddNode(newnode, root->rchild);
    }

    else
    {
        printf("location error !!!\n");
        exit(1);
    }
}


int Max_Depth(BSNode *root)
{
    if(root == NULL)
        return 0;

    int leftdepth = Max_Depth(root->lchild);
    int rightdepth = Max_Depth(root->rchild);

    return (leftdepth > rightdepth) ? leftdepth + 1 : rightdepth + 1;
}

int BSTreeDepth(const BSTree *ptree)
{
    if(ptree != NULL)
    {
        return  Max_Depth(ptree->root);
    }
}

static void DeleteNode(BSNode **delnode)
{
    BSNode *temp;

    if ((*delnode)->lchild == NULL)
    {
        temp = *delnode;
        (*delnode) = (*delnode)->rchild;
        free(temp);
    }

    else if ((*delnode)->rchild == NULL)
    {
        temp = *delnode;
        (*delnode) = (*delnode)->lchild;
        free(temp);
    }

    else
    {
        for (temp = (*delnode)->lchild; temp->rchild; temp = temp->rchild)
            break;

        temp->rchild = (*delnode)->rchild;
        temp = *delnode;
        (*delnode) = (*delnode)->lchild;
        free(temp);
    }
}

static void DeleteAllNode(BSNode *root)
{
    if (root == NULL)
        return;

    BSNode *pright;
    {
        pright = root->rchild;    // 指向右子树
        DeleteAllNode(root->lchild); // 递归删除最左子树节点
        free(root);               // 删除中节点
        DeleteAllNode(pright);       // 删除右节点
    }
}

void DeleteAll(BSTree *ptree)
{
    if(ptree != NULL)
        DeleteAllNode(ptree->root);
    ptree->root = NULL;
    ptree->size = 0;
}

int main()
{
    BSTree root;
    InitBSTree(&root);
    BSTreeInsert(&root, 23);
    BSTreeInsert(&root, 34);
    BSTreeInsert(&root, 13);
    InorderShowBSTree(&root);

    printf("The max_depth is %d\n", BSTreeDepth(&root));

    BSTreeDelete(&root, 34);

    Status result = BSTreeSearch(&root, 43);
   
    if (result == TRUE)
    {
        printf("Found it\n");
    }   

    else
        printf("Not Found\n");

    InorderShowBSTree(&root);

    DeleteAll(&root);
    return 0;
}

测试结果如下所示：
在这里插入图片描述

Serendipity_Shy
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构_排序二叉树(C语言)
小黯
03-22 3056
排序二叉树 1. 结构解析 排序二叉树的结构很简单，只遵循一个规则，那就是在二叉树中，选择任意根结点，其左子树都比根节点小，右子树都比根节点大。 排序二叉树的查找和插入操作理解都非常简单，只需要按照左小右大的规则即可完成查找和插入 观察如下排序二叉树，即可发现排序二叉树的规律，如图： 排序二叉树的删除操作较为难理解，删除操作一共分为三种情况（假设删除的结点为p，并且其父结点为f）： （1）当p结点的右子树不存在时，因为f的右子树都比f结点大，所以我们只需要将p的父结点指向p的指针指向p的左子树即可
数据结构C语言排序方法-堆排序详解！.pdf
最新发布
01-15
【数据结构】C语言排序方法——堆排序详解 堆排序是一种基于比较的排序算法，它利用了二叉堆这一数据结构的特点。堆是一种特殊的树形数据结构，形状近似完全二叉树，同时满足堆积性质：在最大堆中，每个父节点的值...
王道数据结构笔记01-二叉排序树/二叉查找树/BST
testleaf.cn
08-31 3893
二叉排序树，又称二叉查找树（BST，Binary Search Tree） 一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树： 左子树上所有结点的关键字均小于根节点的关键字； 右子树上所有结点的关键字均大于根节点的关键字。 左子树和右子树又各是一棵二叉排序树。 即： 左子树结点值...............................................................................................................
二叉排序树（BST）创建详解之C语言版
sunnyoldboy博客
10-03 7172
二叉排序树（Binary Sort Tree或 Binary Search Tree）又称二叉查找树，可以用来实现数据的快速查找，也方便数据的插入、删除等工作，因此适用于数据的动态查找。
二叉树的建立与查找（C语言）
qq_73884528的博客
05-16 2993
我们建立的二叉树只能向下查找，不能返回上层，所以要达到层次遍历效果可以多次遍历二叉树，每次遍历取其中一层来实现。我们先通过getHeightTree()获取二叉树的总高度，然后在遍历二叉树时分别对每层元素进行了查找。此外，先序遍历，中序遍历，后序遍历也可以采用非递归思路编写，以后补充，再见！所建二叉树较小数插入左侧，较大数插入右侧。建立二叉树过程与之前一样，多了队列建立和相关操作的代码，运行效果如下。通过这段代码可以建立一个二叉树,如图所示。第二种层次遍历可以通过递归方式实现。2.二叉树层次遍历方法。
二叉排序树详解以及实现
Keep_Trying_Go的博客
01-02 2920
二叉排序树详解以及实现
C语言实现二叉排序树
qq_43148788的博客
03-02 2648
C语言实现二叉排序树
运动会成绩管理系统c语言实现
01-30
《运动会成绩管理系统C语言实现详解》 在信息技术领域，开发一个运动会成绩管理系统是提升编程技能、熟悉数据结构和数据库操作的绝佳实践项目。本系统基于C语言实现，旨在帮助我们理解如何利用C语言进行实际应用...
数据结构（C语言版） 第八章 排序 知识梳理 + 习题详解1
08-03
堆排序是建立在完全二叉树上的排序方法，可以看作是选择排序的升级版。它首先将待排序序列构造成一个大顶堆或小顶堆，然后将堆顶元素与末尾元素交换，重复这一过程直到整个序列有序。堆排序的平均时间复杂度为O(n ...
用C语言编写二叉排序树
06-21
有关二叉排序树的程序源代码，清楚的实现了如何让建立二叉排序树，怎样遍历二叉排序树，以及执行删除操作后的遍历。
C语言数据结构二叉排序树完整源码
11-01
这是一个二叉排序树的完整程序 希望有助于大家的理解，更好的学习数据结构和C语言
C语言实现二叉查找树（BST）的基本操作
12-22
我们在上一篇博客中讲解了二叉树，这一次我们来实现二叉树的进阶——二叉查找树（Binary Search Tree），又称二插排序树(Binary Sort Tree)。所以简称为BST。二插查找树的定义如下： 　　1.若左子树不为空，则左子树上所有节点的值均小于它的根节点的值； 　　2.若右子树不为空，则右子树上所有节点的值均大于它的根节点的值； 　　3.左右子树也分别为二叉排序树； 　　二叉排序树的一个重要特点是中序遍历是一个递增序列。示例代码上传至： https://github.com/chenyufeng1991/BinarySearchTree  。 　　（1）节点的构造
二叉排序树 c程序
11-09
数据结构中二叉排序树的构造，使用c语言程序编写
《数据结构》（C语言版）严蔚敏版本 课后习题全部详解
06-05
例如，理解栈的后进先出特性在递归和表达式求解中的应用，掌握二叉搜索树的性质及其在查找和插入操作中的优势，了解图的深度优先搜索和广度优先搜索算法在解决实际问题中的作用。 总的来说，《数据结构》（C语言版...
数据结构二叉排序树应用一
m0_63142359的博客
11-19 3821
数据结构二叉排序树应用一。
C语言 哈希查找（哈希表的创建、处理冲突、查找等）
m0_73070900的博客
06-11 5701
哈希函数的构造方法、处理哈希冲突的方法以及哈希查找的实现。
数据结构实现二叉排序树
m0_54570435的博客
04-25 1603
因为二叉排序树的中序遍历有序性，即得到的递增的序列，由于有序，因此其查找与二分查找类似，每次都可以缩小查找范围，查询效率较高。3、该结点左右子树均不为空，就不能采用子承父业的方法了，根据二叉排序树的中序遍历有序性删除该节点，可以利用其直接前驱或者直接后继来代替被删除节点的位置，然后删除其直接前驱或者直接后继即可。程序主要设计了四个功能：首先是创建二叉排序树，完成后出现任务菜单，以数字代码确定，二叉排序树的中序遍历和查找，删除步骤，最后完成，结束。3、将相邻结点的值赋给删除结点，删除相邻结点。
二叉排序树的C实现（以排序查找为主线，顺带介绍二叉树的实现）（面向新手，大佬勿喷）
weixin_45949006的博客
05-27 217
非线性结构 前面我已经写过线性结构，我说过，线性结构是非线性结构实现的基础，宝贝们是不是还有一点疑惑是什么意思？给你们康康嗷。 二叉树 首先我们第一个要知道的结构就是二叉树，但是对于一般的最抽象的二叉树你可能会有些疑惑，我们直接从一个应用角度出发，来探讨二叉树的各种性质。 首先，二叉树是一种非线性结构，它和单纯的数组和链表不同，它有更加花里胡哨的实现方式。 二叉树是什么个逻辑关系呢，这就好比一个家族，而且国家制定了二胎政策，每个家庭只能最多有两个孩子，就是这种爹和儿子的关系，构成了二叉树的逻辑。 假设Dav

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值