二叉排序树

最新推荐文章于 2022-01-29 15:11:41 发布
最新推荐文章于 2022-01-29 15:11:41 发布
阅读量385 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44994726/article/details/114292501
版权

文章目录

二叉排序树

又称二叉检索树、二叉搜搜索树

一、性质

​ 1、左节点 < 根结点

​ 2、右节点 > 根结点

​ 3、中序遍历的结果，是一个有序序列

二、用途

解决与排名相关的检索需求

点与边的关系：点是集合，边是关系，根结点相当于全集

三、插入

与根结点相比较，小于根结点，递归左边，大于根结点，递归右边，若是递归到叶子结点，变成叶子结点的左孩子或右孩子。

1.插入新节点，一定会作为叶子结点

四、删除

三种情况：

一、度为0：

​ 直接删除，返回空节点

二、度为1：

​ 删除节点后，将子孩子交给父亲结点

三、度为2：

​ 找到前驱后或后继结点进行替换，问题转换为删除度为一的问题。

注意：度为2结点的前驱或者后继的一定为度为1的结点

对于度为二的节点：

1.前驱：左子树中的最大值

2.后继：右子树中的最小值

练习-1

按照如下插入数字，画出对应的二叉树搜索树

1 ：[5, 9, 8, 3, 2, 4, 1, 7]

2 : [1, 2, 3, 4, 5]

在这里插入图片图描述

在这里插入图片描述

1.插入顺序会影响最终的树形结构

2.不同的树形结构，查找效率不同

平均查找效率：节点查找的期望值 总 次 数 节 点 数 量 \frac{总次数}{节点数量} 节点数量总次数​ , 假设每个结点等概率的被查找

五、代码实现

#include <stdio.h>
#include <stdlib.h>
#define KEY(n) (n ? n->key : 0)

typedef struct Node {
    int key;
    struct Node *lchild, *rchild;
} Node;

Node *getNewNode (int val) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->key = val;
    p->lchild = p->rchild = NULL;
    return p;
}

int search_Node(Node *root, int val) {
    if (root == NULL) return 0;
    if (root->key == val) return 1;
    if (root->key < val) return search_Node(root->rchild, val);
    return search_Node(root->lchild, val);
}

Node *insert(Node *root, int val) {
    if (root == NULL) return getNewNode(val);
    if (root->key == val) return root;
    if (root->key < val) root->rchild = insert(root->rchild, val);
    else root->lchild = insert(root->lchild, val);
    return root;
}

Node *predecessor(Node *root) {
    Node *temp = root->lchild;
    while (temp->rchild) temp = temp->rchild;
    return temp;
}

Node *erase(Node * root, int key) {
    if (root == NULL) return NULL;
    if (key < root->key) {
        root->lchild = erase(root->lchild, key);
    } else if (key > root->key) {
        root->rchild = erase(root->rchild, key);
    } else {
        if (root->lchild == NULL && root->rchild == NULL) {
            free(root);
            return NULL;
        } else if (root->lchild == NULL || root->rchild == NULL) {
            Node *temp = root->lchild ? root->lchild : root->rchild;
            free(root);
            return temp;
        } else {
            Node *temp = predecessor(root);
            root->key = temp->key;
            root->lchild = erase(root->lchild, root->key);
        }
    }
    return root;
}

void clear(Node *root) {
    if (root == NULL) return ;
    clear(root->lchild);
    clear(root->rchild);
    free(root);
    return ;
}

void output(Node *root) {
    if (root == NULL) return ;
    output(root->lchild);
    printf("(%d, %d, %d)\n", KEY(root), KEY(root->lchild), KEY(root->rchild));
    output(root->rchild);
    return ;
}
int main() {
    int op, val; // 操作：0：查找 1:插入 2：删除
    Node *root = NULL;
    while (~scanf("%d%d", &op, &val)) {
        switch (op) {
            case 0: printf("search %d, result : %d\n", val, search_Node(root, val)); break;
            case 1: root = insert(root, val); break;
            case 2: root = erase(root, val); break;
        }
        if (op) {
            output(root);
            printf("-------------\n");
        }
    }
    return 0;
}

六、拓展内容

1.二叉排序树的删除代码优化

​ 1.删除掉处理度为0的代码逻辑，不影响代码整体整体功能

2.如何解决排名相关的代码需求

​ 1. 修改二叉树的结构定义，增加size字段，记录每棵树的节点数量

​ 2. k = L − 1 k = L - 1 k=L−1，根结点就是排名第K位的元素

​ 3. k ≤ L S k \le LS k≤LS， 排名第K位的元素在左子树中

​ 4. k > L S ， s e a r c h _ k ( r o o t − > r c h i l d , k − L S − 1 ) k \gt LS， search\_k(root->rchild, k - LS - 1) k>LS，search_k(root−>rchild,k−LS−1)

3.解决Top-k问题（找到小于第k位的所有元素）

​ 1.根结点就是第k位元素的话，就把左子树中的值全部输出出来

​ 2.第K位在左子树中，前k位元素全都在左子树中

​ 3.第k位在右子树中，说明根结点和左子树中的元素，都是前k位元素里的值

4.二叉排序树与快速排序之间的关系

​ 1. 二叉排序树是快速排序在逻辑结构层面用的数据结构

​ 2. 思考1：快速排序的时间复杂度和二叉排序树建树时间复杂度之间的关系

​ 3. 思考2：快速选择算法和二叉排序树之间的关系

​ 4. 程序=算法+数据结构

所谓算法设计及分析能力：分类讨论及归纳总结的能力

七、最终代码

#include <stdio.h>
#include <stdlib.h>
#define KEY(n) (n ? n->key : 0)
#define SIZE(n) (n ? n->size : 0)
#define L(n) (n ? n->lchild : NULL)

typedef struct Node {
    int key;
    int size;
    struct Node *lchild, *rchild;
} Node;

Node *getNewNode (int val) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->key = val;
    p->lchild = p->rchild = NULL;
    p->size = 1;
    return p;
}

void update_size(Node *root) {
    root->size = SIZE(root->lchild) + SIZE(root->rchild) + 1;
    return ;
}

int search_Node(Node *root, int val) {
    if (root == NULL) return 0;
    if (root->key == val) return 1;
    if (root->key < val) return search_Node(root->rchild, val);
    return search_Node(root->lchild, val);
}

Node *insert(Node *root, int val) {
    if (root == NULL) return getNewNode(val);
    if (root->key == val) return root;
    if (root->key < val) root->rchild = insert(root->rchild, val);
    else root->lchild = insert(root->lchild, val);
    update_size(root);
    return root;
}

int search_k(Node *root, int k) {
    if (root == NULL) return -1;
    if (SIZE(L(root)) == k - 1) return root->key;
    if (k <= SIZE(L(root))) return search_k(root->lchild, k);
    return search_k(root->rchild, k - SIZE(L(root)) - 1);
}

Node *predecessor(Node *root) {
    Node *temp = root->lchild;
    while (temp->rchild) temp = temp->rchild;
    return temp;
}

Node *erase(Node * root, int key) {
    if (root == NULL) return NULL;
    if (key < root->key) {
        root->lchild = erase(root->lchild, key);
    } else if (key > root->key) {
        root->rchild = erase(root->rchild, key);
    } else {
        if (root->lchild == NULL && root->rchild == NULL) {
            free(root);
            return NULL;
        } else if (root->lchild == NULL || root->rchild == NULL) {
            Node *temp = root->lchild ? root->lchild : root->rchild;
            free(root);
            return temp;
        } else {
            Node *temp = predecessor(root);
            root->key = temp->key;
            root->lchild = erase(root->lchild, root->key);
        }
    update_size(root);
    }
    return root;
}

void clear(Node *root) {
    if (root == NULL) return ;
    clear(root->lchild);
    clear(root->rchild);
    free(root);
    return ;
}

void print(Node *root) {
    printf("(%d [%d], %d, %d)\n", KEY(root), SIZE(root), KEY(root->lchild), KEY(root->rchild));
    return ;
}

void output(Node *root) {
    if (root == NULL) return ;
    output(root->lchild);
    print(root);
    output(root->rchild);
    return ;
}

void output_k(Node *root, int k) {
    if (root == NULL || k == 0) return ;
    if (k <= SIZE(L(root))) {
        output_k(root->lchild, k);
    } else {
        output(root->lchild);
        print(root);
        output_k(root->rchild, k - SIZE(L(root)) - 1);
    }
    return ;
}

int main() {
    int op, val; // 操作：0：查找 1:插入 2：删除 3：查找第k元素 4：打印前Top-k元素
    Node *root = NULL;
    while (~scanf("%d%d", &op, &val)) {
        switch (op) {
            case 0: printf("search %d, result : %d\n", val, search_Node(root, val)); break;
            case 1: root = insert(root, val); break;
            case 2: root = erase(root, val); break;
            case 3: printf("search_k = %d, result : %d\n", val, search_k(root, val)); break;
            case 4: { output_k(root, val); printf("------------\n"); }break;
        }
        if (op == 1 || op == 2) {
            output(root);
            printf("-------------\n");
        }
    }
    return 0;
}
北方的烈阳
关注
专栏目录
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
C++入门教程（12）快速排序（二叉树）
CV战士的日常
03-10 2100
快速排序的思路比较有趣， 1）首先找到一个值，以这个值为基准，将所有比这个数小的数都放在这个值的左边，将所有比这个值大的数都放在这个值的右边 2）记下来将找出来左边的和右边的值都按照这个方法排序 3）直到每个排序的数组都只剩下两个或一个数字，即可完成比较 在实现的过程也是比较有意思，基数比较容易找，可以默认以当前数组的第一位为基数，那么怎么用程序去实现把比基数大和比基数小的两组数区分开来呢？区分开来后我们将得到一个这样的结构 ...
数据结构——二叉排序树(BST)+图文精讲
girls的博客
08-17 7111
二叉排序树（简称BST） 又称二叉查找（搜索）树，其定义为：二叉排序树或者是空树，或者是满足如下性质（BST性质）的二叉树： ①： 若它的左子树非空，则左子树上所有结点值（指关键字值）均小于根结点值； ②： 若它的右子树非空，则右子树上所有结点值均大于根结点值； ③： 左、右子树本身又各是一棵二叉排序树。 注意：二叉排序树中没有相同关键字的结点。 二叉排序树的中序遍历序列有什么特点？ 答：中序遍历二叉排序树会得到一个升序的序列。 二叉排序树的结点类型如下： typedef struct node {
数据结构/数据结构与算法实验四 二叉排序树与快速排序（查找与排序算法的实现）
zombotany的博客
01-29 3868
目录1.实验题目2.实验要求查找实验要求实现以下功能：排序实验要求：3.算法思路1.建立二叉排序树2.遍历二叉排序树3.删除节点4.查找并记录访问次数5.利用快速排序的思想将负数排在正数前4.输出演示5.源代码题目1binarySortTree.hbinTreeNode.hmain.cpp第二题main.cpp 1.实验题目 1.已知二叉树T的结点形式为(lchild、data、count、rchild)，其中count为查找次数计数。在树中查找值为X的结点，若找到则该结点的count加1，函数返回值为TR
二叉树实现快速排序
微笑的小小刀
09-26 2189
二叉树在我们印象中是这样的快速排序在我们的印象中是这个样子的：两者看起来长的不一样，结构也不一样，怎么就会扯上关系呢， 按我们一惯的思路，在想着计算机怎么做之前，我们要先用人脑想出来，然...
二叉排序树（二叉搜索树）
Ronz 的博客
01-23 1242
一、二叉排序树概述 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大（如果有相同的值，则该节点放在左子节点或右子节点都可）。在一般情况下，二叉排序树的查询效率比链表结构要高。 如下图所示就是一个二叉排序树： 二、二叉排序树的基本操作 2.1 创建和遍历二叉排序树 【案例描述】 给定如下数组： arr = {7, 3, 10, 12,
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键性质： 1. 左子树上的所有节点的值都小于当前节点的值。 2. 右子树上的所有节点的值都大于当前...
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
Java实现二叉排序树
09-02
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉排序树中，对于...
二叉排序树实现教师成果管理系统源码
01-09
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值，且满足以下性质：对于任意节点，其左子树中所有节点的键值均小于该节点的键值；其右子树中所有...
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
最新发布
02-10
其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：1.若它的左子树非空，则左子树上所有结点的值均小于根结点的值；2.若它的右子树非空，则右子树上所有结点的值均大于根结点的值；3.左、右子树本身又各...
数据结构实验-二叉排序树算法
10-26
掌握二叉排序树的存储方法，实现二叉排序树的创建、查找、插入、删除、平均查找长度等基本操作。 三、实验内容及要求 1、构造二叉排序树的存储结构。 2、实现创建、查找、插入、删除、平均查找长度等操作。
数据结构综合课设二叉排序树.docx
03-26
【二叉排序树详解】 二叉排序树，也称为二叉搜索树，是一种特殊类型的二叉树，它的每个节点都遵循以下规则： 1. 左子树中的所有节点的值都小于当前节点的值。 2. 右子树中的所有节点的值都大于当前节点的值。 3. ...
二叉树排序和绘制技巧
weixin_44247388的博客
04-12 7294
二叉树排序和绘制技巧 题1.有一颗二叉树，如下图所示，将它按先序、中序、后序排列 先序遍历： 先写出根节点A和它的孩子：ABC 在B后插入B的两个孩子：ABDEC 在E后插入E的一个孩子：ABDEGC 在C后插入C的一个孩子：ABDEGCF 在F后插入F的两个孩子：ABDEGCFHI 中序遍历 先写出根节点A和它的两个孩子：BAC 以B为根结点在C前后插入B的两个孩子：DBEAC 以C为根节点在...
C语言实现二叉排序树的基本运算算法
追溯的博客
12-07 4253
二叉排序树的创建、查找和删除过程及其算法设计。 （1）由关键字序列（4,9,0,1,8,6,3,5,2,7）创建一棵二叉排序树bt并以括号表示法输出； （2）判断bt是否为一棵二叉排序树； （3）采用递归和非递归两种方法查找关键字6的节点，并输出其查找路径； （4）分别删除bt中关键字为4和5的结点，并输出删除后的二叉排序。 代码： //文件名:exp9-4.cpp #include
快速排序和二叉树排序
qqqgg的专栏
03-09 2960
快速排序，是把数据分为两堆，递归下去。既然是分成2堆，那么，就于二叉树有关系了，都是2！其实二者的思想是一样的。二叉树把数据拆分的思路，比直接讲快速排序更容易理解。最终二叉树遍历用中序遍历，就取出排序结果。 ...
二叉树(快速排序法)
小男孩tom的博客
12-06 1233
PHP实现 $arr = [1,3,5,7,9,2,4,6,8,10]; $res = kspx($arr); print_r($res); function kspx($arr){ if (count($arr) <= 1){ return $arr; } //快速排序 $base[] = $arr[0]; $left = []; $right = []; for ($i...
C语言实现二叉排序树
"这篇文章主要介绍了如何使用C语言实现二叉排序树（Binary Search Tree, BST）。二叉排序树是一种特殊的数据结构，具有左子节点小于父节点、右子节点大于父节点的特性，使得查找、插入和删除操作的平均时间复杂度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值