数据结构一一二叉搜索树

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

什么是树

树在计算机科学里，是一种十分常见的数据结构，几乎所有操作系统都将文件存放在树状的结构里。

在这里插入图片描述

从上面的图来看，树是由节点和边构成，整棵树有一个最上端节点，称为跟节点。每个节点可以拥有具方向性的边用来和其他节点相连。相连的节点中，在上者称为父节点，在下者称为子节点。无子节点称为叶节点。子节点可以存在多个，如果最多只允许两个子节点，即所谓二叉树。根节点的至任何节点之间有唯一的路径，路径所经过的边数为路径长度。

整棵树的高度，便以跟节点的高度来代表，节点A->B之间如果存在一条路径，那么A称为B的祖代，B称为A的子代。任何节点大小是指其所有子代的节点总数。

本文会对树的基本概念做介绍，但重点介绍二叉搜索树。

二叉搜索树

所谓的二叉树，其意义是：“任何节点最多只允许两个子节点”这两个子节点称为左子节点和右子节点，如果以递归的方式来定义二叉树，可以说：“一个二叉树如果不为空，便是由一个根节点和左右两个子树构成；左右子树都可能为空”。

图1-1所示是一棵二叉搜索树：
在这里插入图片描述

二叉搜索树的节点放置规则是：**任何节点的键值大于其左子树中的每一个节点的键值，并小于其右子树中的每一个节点的键值。**从根节点一直往左走，直到无路可走，即得到最小的元素；从根节点一直往右走，直到无路可走，即得到最大元素。

要在一棵二叉搜索树中找到最大元素或最小元素，是一件简单的事情，就像上面说的一样，一直往左走或一直往右走即是。

最大元素：

ElemType FindMax(BTreePtr T) {
    ElemType max;

    while(T != NULL) {
        max = T->data;
        T = T->rchild;
    }
    return max;
}

最小元素：

ElemType FindMin(BTreePtr T) {
    ElemType min;

    while(T != NULL) {
        min = T->data;
        T = T->lchild;
    }
    return min;
}

比较麻烦的是元素的插入和移除。图1-2是二叉搜索树的元素插入操作图解。插入新元素时，可从根节点开始，遇到键值较大的向右子树插入，遇键值较小者就向左子树插入。

插入节点值16，与根节点比较，比根节点小，因此将插入到左子树。

在这里插入图片描述
二叉搜索树的插入：

int Insert(BTreePtr *T, ElemType e) {

    BTreePtr p;
    //创建一个节点
    if (*T == NULL) {
        *T = (BTreePtr)malloc(sizeof(BTree));
        (*T)->data = e;

        return TRUE;
    } else {
        p = *T;
        while ( p != NULL) {
            //比当前节点大，则插入到右子树
            if (e > p->data) 
            {

                if (p->rchild == NULL) 
                {
                    p->rchild = (BTreePtr) malloc (sizeof(BTree));
                    p->rchild->data = e; //将节点信息存储在此右叶子节点中
                    return TRUE;
                }
                p = p->rchild;
            } 
            else  //比当前节点小，则插入到左子树
            {

                if (p->lchild == NULL)
                {
                    p->lchild = (BTreePtr) malloc (sizeof(BTree));
                    p->lchild->data = e;//将节点信息存储在此左叶子节点中
                    return TRUE;
                }
                p = p->lchild;
            }
        }
    }

    return FALSE;
}

二叉搜索树的移除，需要考虑很多情况：
1.删除的节点为叶子节点，直接删除
2.删除的节点有一个子节点，可以将该子节点作为其父节点的子节点
3.删除的节点有两个子节点，我们可以采取这样的策略：用右子树最小值代替该节点，并递归删除那个节点值。需要递归删除是因为这个最小值的节点可能还有右子树，因此需要做同样的删除操作（它不会有左子树，因为它自己的值最小）

在这里插入图片描述
删除旧值15，可以看出数值15只有一个子节点，直接将其子节点连至其父节点。

在这里插入图片描述
删除旧值12，有两个子节点，以右子树中的最小值取而代之。

int Delete(BTreePtr T, ElemType e) 
{
    BTreePtr p, pp, minP, minPP, child;
    child = NULL;
    p = T;
    pp = NULL;

    while ( (p != NULL) && (p->data != e) ) {
        pp = p;

        if (e > p->data) //比当前节点值大，从右子树查找并删除
        {
            p = p->rchild;
        } 
        else //比当前节点值小，从左子树查找并删除
        {
            p = p->lchild;
        }
    }

    if (p == NULL) return FALSE;

    //双节点
    if ((p->lchild != NULL) && (p->rchild != NULL))
    {
        minPP = p;
        minP = p->rchild;

        while (minP->lchild != NULL) {
            minPP = minP;
            minP = minP->lchild;
        }
        p->data = minP->data;
        minPP->lchild = minP->rchild;
        free(minP);

        return TRUE;
    }

    //有一个节点
    if ((p->lchild != NULL) || (p->rchild != NULL)) { //应该将原有的pp同child连接在一起

        if (p->lchild) {
            child = p->lchild;
        } else {
           child = p->rchild;
        }
        if(pp->data>p->data)
        {
            pp->lchild=child;
        } else
        {
            pp->rchild=child;
        }
        free(p);
        return TRUE;
    }

    //没有节点
    if (pp->lchild == p) {//这里面临pp除p以外的节点为null的情况
        pp->lchild = child;
    } else {
        pp->rchild = child;
    }

    return TRUE;
}

二叉搜索树 完整代码如下：

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef char ElemType;

typedef struct node 
{
    ElemType data;
    struct node *lchild, *rchild;
} BTree, *BTreePtr;

//插入 
Status Insert(BTreePtr *T, ElemType e) {

    BTreePtr p;

    if (*T == NULL) {
        *T = (BTreePtr)malloc(sizeof(BTree));
        (*T)->data = e;

        return TRUE;
    } else {
        p = *T;
        while ( p != NULL) 
        {

            if (e > p->data) 
            {

                if (p->rchild == NULL) 
                {
                    p->rchild = (BTreePtr) malloc (sizeof(BTree));
                    p->rchild->data = e;
                    return TRUE;
                }
                p = p->rchild;
            } 
            else 
            {

                if (p->lchild == NULL)
                {
                    p->lchild = (BTreePtr) malloc (sizeof(BTree));
                    p->lchild->data = e;
                    return TRUE;
                }
                p = p->lchild;
            }
        }
    }

    return FALSE;
}

// 删除 
Status Delete(BTreePtr T, ElemType e) {
    BTreePtr p, pp, minP, minPP, child;
    child = NULL;
    p = T;
    pp = NULL;

    while ( (p != NULL) && (p->data != e) ) 
    {
        pp = p;

        if (e > p->data) {
            p = p->rchild;
        } else {
            p = p->lchild;
        }
    }

    if (p == NULL) return FALSE;

    //双节点
    if ((p->lchild != NULL) && (p->rchild != NULL))
    {
        minPP = p;
        minP = p->rchild;

        while (minP->lchild != NULL) 
        {
            minPP = minP;
            minP = minP->lchild;
        }
        p->data = minP->data;
        minPP->lchild = minP->rchild;
        free(minP);

        return TRUE;
    }

    //有一个节点
    if ((p->lchild != NULL) || (p->rchild != NULL)) //应该将原有的pp同child连接在一起
    { 

        if (p->lchild) 
        {
            child = p->lchild;
        } else {
           child = p->rchild;
        }
        if(pp->data>p->data)
        {
            pp->lchild=child;
        } else
        {
            pp->rchild=child;
        }
        free(p);
        return TRUE;
    }

    //没有节点
    if (pp->lchild == p) //这里面临pp除p以外的节点为null的情况
    {
        pp->lchild = child;
    } else {
        pp->rchild = child;
    }

    return TRUE;
}

// 查找 

Status Find(BTreePtr T, ElemType e) 
{

    if (T == NULL) return FALSE;

    while ((T != NULL) && (T->data != e))
     {

        if (e > T->data) {
            T = T->rchild;
        } else {
            T = T->lchild;
        }
    }

    if (T) {
        return TRUE;
    } else {
        return FALSE;
    }
}


// 最大值 
ElemType FindMax(BTreePtr T) 
{
    ElemType max;

    while(T != NULL) 
    {
        max = T->data;
        T = T->rchild;
    }
    return max;
}


//最小值 
ElemType FindMin(BTreePtr T) 
{
    ElemType min;

    while(T != NULL) 
    {
        min = T->data;
        T = T->lchild;
    }
    return min;
}


void PreOrderTraverse(BTreePtr T)//前序遍历二叉树
{
    if (T == NULL) return;

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


void DestroyTree(BTreePtr T) {
    if (T)
    {
        if (T->lchild)
        {
            DestroyTree(T->lchild);
        }

        if(T->rchild)
        {
            DestroyTree(T->rchild);
        }

        free(T);
        T = NULL;
    }
}


int main(int argc, char const *argv[])
{
    BTreePtr T;
    T = NULL;
    int a[] = {33, 16, 50, 13, 18, 34, 58, 15, 17, 25, 51, 66, 19, 27, 55};
    int i;
    for (i = 0; i < 15; i++) {
        Insert(&T, a[i]);
    }
    printf("Max is %d\n", FindMax(T));
    printf("Min is %d\n", FindMin(T));
    Delete(T, 18);
    Delete(T, 13);
    PreOrderTraverse(T);
    DestroyTree(T);

    return 0;
}

输出结果：
在这里插入图片描述
在这里插入图片描述
扫二维码关注微信公众号，获取技术干货

参考：STL 源码解析

程序猿编码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javascript数据结构之二叉搜索树实现方法
11-24
二叉搜索树：顾名思义，树上每个节点最多只有二根分叉；而且左分叉节点的值 < 右分叉节点的值 。 特点：插入节点、找最大/最小节点、节点值排序 非常方便 二叉搜索树-javascript实现 [removed] // <![CDATA[ ...
数据结构中的二叉搜索树
Ethan的博客
09-22 498
文章转载自http://www.cnblogs.com/xpjiang/p/4569591.html 什么是二叉搜索树 二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树：一颗二叉树，可以为空；如果不为空，满足以下性质： 非空左子树的所有键值小于其根结点的键值非空右子树的所有键值大于其根结点的键值左、右子树都是二叉搜索树 二叉
数据结构：二叉查找树的实现
H的博客
09-25 256
二叉查找树 二叉树是节点最多只有两个子树的树状结构，这两个子树可以称为左子树和右子树。可是对于普通的二叉树，并没有足够的信息来提示我们左子树和右子树存储的是什么，我们没有办法进行高效的信息查找。为了提高查找效率，我们会把二叉树升级为二叉查找树(Binary Search Tree)。 二叉查找树是符合以下定义的二叉树： 1.节点左子树中全部的节点键值都比该节点要小。 2.节点右子树中全部...
一颗二叉搜索树
Miss_Eleven
04-26 199
二叉搜索树是一颗度为2的数，且左子树都不大于根节点，右子树都不小于根节点。 以下分步实现一个简单的二叉搜索树 节点 二叉搜索树上的节点保存着一个值value, 指向父节点的指针，以及两个指向左右兄弟的指针。简单的实现如下： public class Node { T value; Node parent; Node left; ...
数据结构-二叉搜索树
Python+大数据+数据分析+自动化+Vue组件开发
11-26 381
思考   在n个动态的整数中搜索某个整数?(查看其是否存在)   假设使用动态数组存放元素，从第 0 个位置开始遍历搜索，平均时间复杂度:O(n)。如果维护一个有序的动态数组，使用二分搜索，最坏时间复杂度:O(logn) 但是添加、删除的平均时间复杂度是 O(n)   针对这个需求，有没有更好的方案?   今天我们主要讲的就是二叉搜索树，使用二叉搜索树，添加、删除、搜索的最坏时间复杂度均可优化至:O(logn)。 概念   树是一种数据结构，比如二叉树、B树、红黑树等等，也有3叉树等等。但是..
实现一颗二叉搜索树（Java）
qq_45691220的博客
05-16 259
1， 首先简单介绍一下 （1）二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索 (2)二叉搜索树的中序遍历结果是递增的有序序列 (3)二叉搜索树中不允许存在在值相同的结点 图示： 2.操作 （1）查询操作 查询操作类似于二分查找，包含三种情况 不为空树且树中存在一个结点的值等于要查找元素的情况 下 如果要查找元素小于根节点的值就
Nginx源码初探之数据结构 – 基数树数据结构
01-07
 基数树也叫做压缩前缀树，是一种多叉搜索树，对比其他结构跟节省空间。基数树常见于IP路由检索，文本文档的的倒排索引等场景中。同时基数树也是按照字典顺序来组织叶节点的，这种特点使之适合持久化改造，加上他的...
数据结构 二叉搜索树
11-27
此程序用C++实现了数据结构中二叉搜索树，希望有所帮助
C++/C 数据结构1800题及答案
04-12
数据结构与算法课程内容包括数据结构与抽象数据类型、算法特性及分类、算法效率与度量、线性结构、顺序表、链表、栈与队列、栈与递归、递归转非递归、字符串的存储结构、字符串运算的算法实现、字符串的快速模式匹配...
二叉搜索树的插入删除_二叉搜索树_python_
09-29
python数据结构与算法，二叉搜索树的操作，来源中山大学软件学院考试参考代码
一颗二叉查找树的简单实现
kuangle的博客
03-20 278
第一次实现的二叉查找树，在别的大牛的博客学习了很久很久。发现由于其使用的技巧较多，不适用与新手模仿，所以自己实践写出了一个有局限性，功能专一化，不完整的二叉查找树。        使用了c++中的类来定义节点，并没有定义专门的树类，以减小代码复杂性。class BSTNode{ private: int key; BSTNode *
数据结构_二叉搜索树
xc13212777631的博客
06-21 442
二叉搜索树 所谓的查找，指从一组数据对象中找出符合特定条件者。其中的数据对象，统一的表示和实现为词条（entry）的形式；不同的数据项之间，依照各自的关键码（key）彼此区分。 一般而言词条应以如下形式： template &amp;lt;typename K, typename V&amp;gt; struct Entry { //词条模板类 K key; V value; //关键码、数值...
树（一）：二叉查找树
12-13 583
树（二）平衡二叉树 一、二叉查找树的定义 二叉查找树（BST，Binary Search Tree），也称为二叉排序树或者二叉搜索树，是二叉树的一种。二叉查找树与二叉树一样，可以为空；另外，如果不为空，作为二叉查找树需满足以下性质： 1. 非空左子树的所有键值小于其根节点的键值； 2. 非空右子树的所有键值大于其根节点的键值； ...
二叉搜索树基本数据结构实现
Tander_Tang的博客
03-04 465
二叉搜索树基本数据结构实现，非递归与递归。二叉搜索树中一个结点包含3个指针left,right, prev和一个卫星数据key。这三个指针分别指向左儿子，右儿子，父节点。如果孩子结点和父亲结点不存在，相应指针为空。根结点的prev指向空。      1）遍历（中序遍历，先序遍历，后续遍历）     2）查找一个关键字，返回该关键字的结点指针     3).返回最大关键字最小关键字结点指针     4)寻找关键字key的后继结点
【数据结构】搜索树
LazyFish的博客
04-05 362
二叉搜索树 Binary Search Tree   静态查找， 动态查找 无序链表：灵活性好 有序数组：效率高 直接把元素放在树上，树的动态性强。 这种方式查找，即灵活又效率高。   二叉搜索树，又称有序二叉树，排序二叉树 顾名思义用来排序，何以排序，键值比大小 键 ： key  排序用的是key，权值 值  ：value  有意义的数据 性质： 1.非空左子树的键值...
3、【数据结构】树形结构之二叉查找树
阿牧路泽
10-26 215
一、树的介绍 1. 树的定义     树是一种数据结构，它是由n（n&amp;amp;amp;amp;gt;=1）个有限节点组成一个具有层次关系的集合。 　　把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 　　(1) 每个节点有零个或多个子节点； 　　(2) 没有父节点的节点称为根节点； 　　(3) 每一个非根节点有且只有一个父节点； 　　(4) 除了根节点外，每个子节点可以分为多...
【算法面试】二叉搜索树
nuoWei_SenLin的博客
02-03 3011
每一个内心仰望理想的人，都在低头干活  摘要 顾名思义，二叉搜索树是由两个孩子节点组成的树状的数据结构，由于其特殊的性质，任意一个节点的左子树的每个节点总比这个节点小，右子树的每个节点总比这个节点大，所以二叉搜索树的查询性能比较好。 本文只讲解二叉搜索树，二叉平衡树不是本文重点  正文 不得不承认，递归思想在二叉树中展现的淋漓尽致，本文讲解的二叉搜索树主要操作如下： ...
[数据结构]——二叉树（Binary Tree）、二叉搜索树（Binary Search Tree）及其衍生算法...
weixin_30362233的博客
12-21 178
二叉树（Binary Tree）是最简单的树形数据结构，然而却十分精妙。其衍生出各种算法，以致于占据了数据结构的半壁江山。STL中大名顶顶的关联容器——集合（set）、映射（map）便是使用二叉树实现。由于篇幅有限，此处仅作一般介绍（如果想要完全了解二叉树以及其衍生出的各种算法，恐怕要写8~10篇）。 1）二叉树（Binary Tree） 顾名思义，就是一个节点分出两个节点，称其为左右子节点；...
数据结构与算法 — 二叉搜索树 及其操作与实现、二叉搜索树的缺陷
m0_59897687的博客
01-11 416
目录 一、二叉搜索树 二、二叉搜索树的操作及实现 1.插入数据 2.遍历二叉搜索树 (1).先序遍历 (2).中序遍历 (3).后序遍历 3.最大值和最小值 4.搜索特定的值 5.二叉搜索树的删除 (1).查找到要删除的节点 (2).删除的节点是叶子节点 (3).删除的节点有一个子节点 (4).删除的节点有两个子节点 三、二叉搜索树的缺陷 一...
Mysql 底层数据结构
最新发布
09-11
B树是一种多叉搜索树，它的特点是可以高效地支持数据的插入、删除和查找操作。通过在B树上建立索引，Mysql可以快速定位到需要查询的数据。 B树是一种平衡的树结构，它具有以下几个特点： - 每个节点可以包含多个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值