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

最新推荐文章于 2024-07-21 22:46:16 发布
最新推荐文章于 2024-07-21 22:46:16 发布
阅读量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语言简单实现)
DFGOMC的博客
11-22 3213
二叉排序树(C语言简单实现) 本文参考自《大话数据结构》 如果查找的数据集是有序线性表，并且是顺序存储的，查找可以用折半、插值、斐波那契等查找算法来实现，可惜，因为有序，在插入和删除操作上，就需要耗费大量的时间。 二叉排序树（Binary Sort Tree），又称为二叉查找树。它或者是一棵空树，或者是具有下列性质的二叉树。 若它的左子树不空，则左子树上所有结点的值均小于它的根结构的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树； 构造一棵二叉
二叉树的C语言实现及遍历
sy1227081317的博客
01-23 1973
前言 树是一种十分重要的基础数据结构。很多实际问题都会抽象成树来解决。而这篇文章要讲的二叉树则是树中最基本又很重要的一种特殊树。它只的是每个节点的度不大于2的树。 基于二叉树还有很多衍生的树。查找树，红黑树，平衡树等等等等。 基础思路 二叉树可以很形象的看做是一个递归的产物。所以二叉树的问题，基本都可以用递归来解决。无论一颗二叉树是什么样子的。他都可以看做三部分：本节点，左子树，右子树。 左子树也可以看成本节点，左子树，右子树。这样的结构。 就像图片上这样。所以一个树的节点需要三部分。保存本节点的数据。
王道数据结构笔记01-二叉排序树/二叉查找树/BST
testleaf.cn
08-31 3902
二叉排序树，又称二叉查找树（BST，Binary Search Tree） 一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树： 左子树上所有结点的关键字均小于根节点的关键字； 右子树上所有结点的关键字均大于根节点的关键字。 左子树和右子树又各是一棵二叉排序树。 即： 左子树结点值...............................................................................................................
【数据结构】树（五）—— 二叉排序树（C语言版）
热门推荐
haoweixl的博客
09-05 1万+
【数据结构】二叉排序树（C语言版）前言一、二叉排序树的定义二、二叉排序树的性质三、二叉排序树的操作二叉排序树常用存储结构二叉排序树的查找(递归实现)查找"二叉树T"中键值为 key 的节点(非递归实现)查找"二叉树T"中键值为 key 的节点二叉排序树的插入二叉排序树的创建二叉排序树的删除四、二叉树的查找性能分析应用区分：（与二分查找的应用区分）二叉排序树的构造树结构分析完整可运行代码 前言 二叉排序树(Binary Sort Tree,BST)又称为二叉查找树、二叉搜索树。与树型查找有关的结构有二叉排序树
二叉排序树（BST）创建详解之C语言版
sunnyoldboy博客
10-03 7177
二叉排序树（Binary Sort Tree或 Binary Search Tree）又称二叉查找树，可以用来实现数据的快速查找，也方便数据的插入、删除等工作，因此适用于数据的动态查找。
二叉排序树（BST）查找算法详解之C语言版
sunnyoldboy博客
10-04 3587
在二叉排序树上查找某个结点，其实就是遍历二叉树。由于二叉排序树上的结点是有序的，因此不需要使用普通二叉树的遍历算法，其有自己一套简单的遍历算法，即从树根开始进行遍历，如果待查找元素小于树根元素，则向左遍历，否则向右遍历，如果相等结束遍历。
二叉树的建立与查找（C语言）
qq_73884528的博客
05-16 2996
我们建立的二叉树只能向下查找，不能返回上层，所以要达到层次遍历效果可以多次遍历二叉树，每次遍历取其中一层来实现。我们先通过getHeightTree()获取二叉树的总高度，然后在遍历二叉树时分别对每层元素进行了查找。此外，先序遍历，中序遍历，后序遍历也可以采用非递归思路编写，以后补充，再见！所建二叉树较小数插入左侧，较大数插入右侧。建立二叉树过程与之前一样，多了队列建立和相关操作的代码，运行效果如下。通过这段代码可以建立一个二叉树,如图所示。第二种层次遍历可以通过递归方式实现。2.二叉树层次遍历方法。
数据结构之查找(五)——二叉排序树
daocaoren_的博客
08-09 4080
当表插入、删除操作频繁时，为了维护表的有序性，需要移动表中的很多记录。 所以改用动态查找表——几种特殊的树。其表结构在查找的过程中动态生成。 对于给定的key，若表中存在，则成功返回；否则，插入关键字等于key的记录。 这样的动态查找表有：二叉排序树，平衡二叉树，红黑树，B-树，B+树以及键树等。 二叉排序树的定义 定义： 二叉排序树或是空树，或是满足如下性质的二叉树： 若其左子树非空，则...
二叉排序树
11-03
- **总结**：本文详细介绍了如何使用C语言实现二叉排序树及其基本操作。通过定义合适的结构体类型，可以方便地在树中插入、删除和查找节点。 - **应用场景**： - 数据管理：例如数据库系统中的索引。 - 应用程序...
C 二叉排序树
06-20
### C语言实现的二叉排序树详解 #### 核心概念与原理 二叉排序树（Binary Search Tree，简称BST）是一种特殊的二叉树结构，其中每个节点具有以下特性： - 节点的左子树只包含键值小于该节点键值的节点。 - 节点的...
二叉排序树_非线性结构_数据结构与算法
02-08
### 二叉排序树知识点详解 #### 一、二叉排序树定义 二叉排序树(Binary Search Tree, BST)，也称作二叉查找树或有序二叉树，是一种特殊的二叉树，它满足以下性质： - 每个节点包含一个键（Key）和一个关联的值...
数据结构C语言排序方法-堆排序详解！.pdf
01-15
【数据结构】C语言排序方法——堆排序详解 堆排序是一种基于比较的排序算法，它利用了二叉堆这一数据结构的特点。堆是一种特殊的树形数据结构，形状近似完全二叉树，同时满足堆积性质：在最大堆中，每个父节点的值...
C++代码，数据结构-二叉排序树
y519476132的专栏
02-13 808
#include #include #include #include using namespace std; //排序二叉树的建立，遍历，，，利用排序二叉树来进行排序 struct Binode{ int data; Binode *lchild,*rchild; }; typedef Binode* Bitree; //从空树出发，经过一系列的查找插入操作之后，可
二叉排序树详解以及实现
Keep_Trying_Go的博客
01-02 2923
二叉排序树详解以及实现
二叉排序树 -- C语言
六六哥的博客
02-23 392
数据结构 二 叉 排序 树（ Binary Sort Tree） 又称 二 叉 查找 树（ Binary Search Tree）。 其 定义 为： 二 叉 排序 树 或者是 空 树， 或者是 满足 如下 性 质的 二 叉 树。 （1） 若 它的 左 子 树 非 空， 则 左 子 树上 所有 节点 的 值 均 小于 根 节点 的 值。 （2） 若 它的 右 子 树 非 空， 则 右 子 树上...
C语言实现二叉排序树
qq_43148788的博客
03-02 2650
C语言实现二叉排序树
二叉排序树C语言实现（超级详细代码）
nidayededaye2的博客
12-12 7163
今天来给大家讲解一下二叉排序树C语言代码实现 typedef int ElemType; // 自定义数据元素为整数。 // 二叉树的数据结构。 typedef struct BSTNode { ElemType data; // 存放结点的数据元素。 struct BSTNode* lchild; // 指向左子结点地址的指针。 struct BSTNode* rchild; // 指向右子结点地址的指针。 ..
Windows图形界面(GUI)-DLG-C/C++ - 日期时间控件(DateTimePicker)
最新发布
0xCC说逆向
07-21 398
【代码】Windows图形界面(GUI)-DLG-C/C++ - 日期时间控件(DateTimePicker)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值