数据结构（七）——查找之二叉排序树

最新推荐文章于 2022-04-30 18:46:52 发布
最新推荐文章于 2022-04-30 18:46:52 发布
阅读量280 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Double___H/article/details/94858615
本文介绍了二叉排序树的构造过程，包括不同输入数据时如何构造节点，并详细讨论了删除二叉排序树节点的三种情况。此外，还提到了中序遍历的应用。最后，提供了具体的源代码和测试样例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

代码中所用到的结构体

typedef struct Node
{
    int elem;//存放数据
    struct Node *lchild, *rchild;
    struct Node *prev;
} TreeNode, *BiTree; //定义树节点的结构体
typedef struct tree
{
    BiTree root;
}Tree,*pTree;

构造二叉排序树

  • 以第一个输入的数据作为排序二叉树的根。
  • 对数数据的输入分为6种情况：
  • 1.当树不存在的时候，当前数据作为树的根；
  • 2.当树中存在此数据时，打印“此数据已存在”；
  • 3.输入数据小于当前结点且当前结点无左儿子，则输入数据作为当前结点的左儿子；
  • 4.输入数据小于当前结点且当前结点有左儿子，则将当前结点指针移动到左儿子，继续比较；
  • 5.输入数据大于当前结点且当前结点无右儿子，则输入数据作为当前结点的右儿子；
  • 6.输入数据大于当前结点且当前结点有右儿子，则将当前结点指针移动到右儿子，继续比较；
  • 结束条件为输入 -1
void CreateBST(pTree T)//构造二叉排序树
{
    int e=0;//初始化
    while(1)//while循环建立二叉排序树
    {
        printf("Please input the child of BST:");
        printf("(input will over when you input -1.)\n");
        scanf("%d",&e);//插入的数据
        getchar();
        if(e==-1)//非法判断
        {
            break;
        }
        BiTree n1=(BiTree)malloc(sizeof(TreeNode));//申请空间
        BiTree n2=T->root;//初始化
        n1->elem=e;
        n1->lchild=NULL;
        n1->rchild=NULL;
        n1->prev=NULL;
        if(T->root==NULL)//当树不存在时
        {
            T->root=n1;
        }
        else//当树存在时
        {
            while(1)//实现二叉树插入
            {
                if(e==n2->elem)//若树中存在此元素
                {
                    printf("this elem has existed!\n");
                    break;
                }
                if(e>n2->elem&&n2->rchild==NULL)
                {
                    n2->rchild=n1;
                    n1->prev=n2;
                    break;
                }
                else if(e>n2->elem)
                {
                    n2=n2->rchild;
                }
                else if(e<n2->elem&&n2->lchild==NULL)
                {
                    n2->lchild=n1;
                    n1->prev=n2;
                    break;
                }
                else if(e<n2->elem)
                {
                    n2=n2->lchild;
                }
            }
        }
    }
}

删除二叉排序树的结点

删除可能出现的几种情况

  • 二叉排序树不存在。
  • 二叉排序树中无将删除的结点。
  • 二叉排序树中存在要删除的结点，并执行删除。

这里，我对第三种查找到了二叉排序树中存在该节点并删除进行展开讨论。

二叉排序树中的删除节点的三种情况
1.即将删除的节点为叶结点。

  • 执行方法，将该叶结点删除，且将原本指向该叶结点的指针指向NULL；

2.即将删除的节点仅存在左子树或者仅存在右子树。（这里以仅存在左子树为例）

  • 寻找即将删除节点的左子树的最右下节点（即左子树中的最大结点），将其赋值给即将删除的结点，赋值完成后再对该最右下结点进行处理。
  • 这里要注意的是，这里删除节点的值被左子树中最大结点覆盖的同时，左子树中的最大结点也要随之删除，这里也要对其讨论是否存在左子树进行讨论。

3.即将删除的结点即存在右子树，也存在左字数。

  • 这里有两种选择，以左子树中的最右下结点（即左子树中的最大结点）进行替换，或是以右子树中的最左下节点（即右子树中的最小结点）进行替换。
  • 同样要注意的是，在替换的时候，要对被拿去替换的点进行讨论，看其是否存在左子树，或右子树。
void DeleteNode(pTree T)//删除二叉排序树的结点
{
    int e;
    BiTree n=T->root;
    BiTree n1=NULL;
    BiTree n2=NULL;
    printf("Please input the elem you want to delete:\n");
    scanf("%d",&e);
    while(1)
    {
        if(n==NULL)//当树为空时
        {
            printf("the Tree is NULL!\n");
            break;
        }
        if(e>n->elem&&n->rchild==NULL)//当元素不存在时
        {
            printf("The elem is not exist!\n");
            break;
        }
        else if(e>n->elem)//当素大于当前结点的数字时
        {
            n=n->rchild;
        }
        else if(e<n->elem&&n->lchild==NULL)//当元素不存在时
        {
            printf("The elem is not exist!\n");
            break;
        }
        else if(e<n->elem)//当元素小于当前结点的数字时
        {
            n=n->lchild;
        }
        else if(e==n->elem)//找到删除的结点
        {
            if(n->lchild==NULL&&n->rchild==NULL)//删除节点为叶子结点
            {
                n1=n->prev;//回溯双亲结点
                if(n1->lchild!=NULL&&n1->lchild->elem==e)//判断当前节点为双亲的左儿子还是右儿子
                {
                    n1->lchild=NULL;
                }
                else
                {
                    n1->rchild=NULL;
                }
                free(n);
            }
            else if(n->lchild==NULL&&n->rchild!=NULL)//删除结点右子树不为空，左子树为空
            {
                n1=n->prev;//回溯双亲
                if(n1->lchild!=NULL&&n1->lchild->elem==e)//判断当前节点为双亲的左儿子还是右儿子
                {
                    n1->lchild=n->rchild;
                }
                else
                {
                    n1->rchild=n->rchild;
                }
                free(n);
            }
            else if(n->rchild==NULL&&n->lchild!=NULL)//删除结点左子树不为空，右子树为空
            {
                n1=n->prev;//回溯双亲
                if(n1->lchild!=NULL&&n1->lchild->elem==e)//判断当前节点为双亲的左儿子还是右儿子
                {
                    n1->lchild=n->lchild;
                }
                else
                {
                    n1->rchild=n->lchild;
                }
                free(n);
            }
            else
            {
                n1=n;
                n1=n->lchild;//走到左子树
                while(n1->rchild!=NULL)//寻找左子树下最右边的结点
                {
                    n1=n1->rchild;
                }
                n->elem=n1->elem;
                if(n->lchild->elem==n1->elem)
                {
                    n->lchild=n1->lchild;
                    free(n1);
                }
                else if(n1->lchild!=NULL)
                {
                    n2=n1->prev;
                    n2->rchild=n1->lchild;
                    free(n1);
                }
                else
                {
                    n2=n1->prev;
                    n2->rchild=NULL;
                    free(n1);
                }
            }
            printf("Delete success!");
            break;
        }
    }

中序遍历

  • 这里以中序遍历排序二叉树。
void inOrderTraverse(BiTree p)//中序遍历
{
    if(p->lchild!=NULL)//判断是否存在左儿子
    {
        inOrderTraverse(p->lchild);//向左儿子走一步
    }
    printf("%d ",p->elem);
    if(p->rchild!=NULL)//判断是否存在右儿子
    {
        inOrderTraverse(p->rchild);
        return;
    }
    else if(p->rchild==NULL)
    {
        return;
    }
}

源代码

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

typedef struct Node
{
    int elem;//存放数据
    struct Node *lchild, *rchild;
    struct Node *prev;
} TreeNode, *BiTree; //定义树节点的结构体
typedef struct tree
{
    BiTree root;
}Tree,*pTree;

void CreateBST(pTree T)//构造二叉排序树
{
    int e=0;//初始化
    while(1)//while循环建立二叉排序树
    {
        printf("Please input the child of BST:");
        printf("(input will over when you input -1.)\n");
        scanf("%d",&e);//插入的数据
        getchar();
        if(e==-1)//非法判断
        {
            break;
        }
        BiTree n1=(BiTree)malloc(sizeof(TreeNode));//申请空间
        BiTree n2=T->root;//初始化
        n1->elem=e;
        n1->lchild=NULL;
        n1->rchild=NULL;
        n1->prev=NULL;
        if(T->root==NULL)//当树不存在时
        {
            T->root=n1;
        }
        else//当树存在时
        {
            while(1)//实现二叉树插入
            {
                if(e==n2->elem)//若树中存在此元素
                {
                    printf("this elem has existed!\n");
                    break;
                }
                if(e>n2->elem&&n2->rchild==NULL)
                {
                    n2->rchild=n1;
                    n1->prev=n2;
                    break;
                }
                else if(e>n2->elem)
                {
                    n2=n2->rchild;
                }
                else if(e<n2->elem&&n2->lchild==NULL)
                {
                    n2->lchild=n1;
                    n1->prev=n2;
                    break;
                }
                else if(e<n2->elem)
                {
                    n2=n2->lchild;
                }
            }
        }
    }
}

void DeleteNode(pTree T)//删除二叉排序树的结点
{
    int e;
    BiTree n=T->root;
    BiTree n1=NULL;
    BiTree n2=NULL;
    printf("Please input the elem you want to delete:\n");
    scanf("%d",&e);
    while(1)
    {
        if(n==NULL)//当树为空时
        {
            printf("the Tree is NULL!\n");
            break;
        }
        if(e>n->elem&&n->rchild==NULL)//当元素不存在时
        {
            printf("The elem is not exist!\n");
            break;
        }
        else if(e>n->elem)//当素大于当前结点的数字时
        {
            n=n->rchild;
        }
        else if(e<n->elem&&n->lchild==NULL)//当元素不存在时
        {
            printf("The elem is not exist!\n");
            break;
        }
        else if(e<n->elem)//当元素小于当前结点的数字时
        {
            n=n->lchild;
        }
        else if(e==n->elem)//找到删除的结点
        {
            if(n->lchild==NULL&&n->rchild==NULL)//删除节点为叶子结点
            {
                n1=n->prev;//回溯双亲结点
                if(n1->lchild!=NULL&&n1->lchild->elem==e)//判断当前节点为双亲的左儿子还是右儿子
                {
                    n1->lchild=NULL;
                }
                else
                {
                    n1->rchild=NULL;
                }
                free(n);
            }
            else if(n->lchild==NULL&&n->rchild!=NULL)//删除结点右子树不为空，左子树为空
            {
                n1=n->prev;//回溯双亲
                if(n1->lchild!=NULL&&n1->lchild->elem==e)//判断当前节点为双亲的左儿子还是右儿子
                {
                    n1->lchild=n->rchild;
                }
                else
                {
                    n1->rchild=n->rchild;
                }
                free(n);
            }
            else if(n->rchild==NULL&&n->lchild!=NULL)//删除结点左子树不为空，右子树为空
            {
                n1=n->prev;//回溯双亲
                if(n1->lchild!=NULL&&n1->lchild->elem==e)//判断当前节点为双亲的左儿子还是右儿子
                {
                    n1->lchild=n->lchild;
                }
                else
                {
                    n1->rchild=n->lchild;
                }
                free(n);
            }
            else
            {
                n1=n;
                n1=n->lchild;//走到左子树
                while(n1->rchild!=NULL)//寻找左子树下最右边的结点
                {
                    n1=n1->rchild;
                }
                n->elem=n1->elem;
                if(n->lchild->elem==n1->elem)
                {
                    n->lchild=n1->lchild;
                    free(n1);
                }
                else if(n1->lchild!=NULL)
                {
                    n2=n1->prev;
                    n2->rchild=n1->lchild;
                    free(n1);
                }
                else
                {
                    n2=n1->prev;
                    n2->rchild=NULL;
                    free(n1);
                }
            }
            printf("Delete success!");
            break;
        }
    }
}
void inOrderTraverse(BiTree p)//中序遍历
{
    if(p->lchild!=NULL)//判断是否存在左儿子
    {
        inOrderTraverse(p->lchild);//向左儿子走一步
    }
    printf("%d ",p->elem);
    if(p->rchild!=NULL)//判断是否存在右儿子
    {
        inOrderTraverse(p->rchild);
        return;
    }
    else if(p->rchild==NULL)
    {
        return;
    }
}

int main()
{
    pTree T=(pTree)malloc(sizeof(Tree));
    BiTree n;
    T->root=NULL;
    CreateBST(T);
    n=T->root;
    inOrderTraverse(n);
    printf("\n");
    DeleteNode(T);
    printf("\n");
    inOrderTraverse(n);
    return 0;
}

测试样例
45
12
53
3
37
100
24
61
90
78
-1
12
样例结果
结果

数据结构——查找(二叉排序树)
weixin_47924016的博客
09-15 2013
二叉排序树查找定义二叉排序树构造二叉排序树查找递归和非递归算法二叉排序树插入递归和非递归算法二叉排序树删除递归和非递归算法二叉排序树查找定义二叉排序树构造二叉排序树查找递归和非递归算法二叉排序树插入递归和非递归算法二叉排序树删除递归和非递归算法。
数据结构复习指导之树形查找（二叉排序树和平衡二叉树）
最新发布
心碎烤肠的博客
05-24 1551
本章是考研命题的重点。 对于折半查找，应掌握折半查找的过程、构造判定树、分析平均查找长度等。 对于二叉排序树、二叉平衡树和红黑树，要了解它们的概念、性质和相关操作等。 B 树和 B+树是本章的难点。对于B树，考研大纲要求掌握插入、删除和査找的操作过程； 对于 B+树，仅要求了解其基本概念和性质。 对于散列查找，应掌握散列表的构造、冲突处理方法(各种方法的处理过程)、查找成功和查找失败的平均查找长度、散列查找的特征和性能分析。
查找完全二叉树底层的最右节点（一）
name_z的专栏
08-24 2167
是面试的时候问到的题目，没有用很多case去测，不保证代码完全正确 题目 节点结构： public class TreeNode { public int val; public TreeNode left; public TreeNode right; public TreeNode(int x) { val = x; } } 完全二叉树： 叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部 给出完全二叉树，返回底层最右节点的.
算法导论 第12章 二叉查找树
程序缘
08-27 2112
二叉查找树是一种树数据结构，它与普通的二叉树最大的不同就是二叉查找树满足一个性质：对于树中的任意一个节点，均有其左子树中的所有节点的关键字值都不大于该节点的关键字值，其右子树中的任意一个节点的关键字值都不小于该节点的关键字值。在二叉查找树上可以进行搜索、取最小值、取最大值、取指定节点的前驱、取指定节点的后继以及插入和删除节点操作，因此二叉查找树和堆（大顶堆和小顶堆）一样，也可以做优先队列，都能够在 O(lgn) 的时间内取得集合的最大值和最小值。一个二叉查找树的期望高度为O(lgn)，因此在二叉查找树上的基
二叉排序树的基本操作
缥缈依梦云
11-22 1026
#include #include typedef struct node {/*定义二叉排序树的结构*/ int  key; struct node *lchild; struct node *rchild; }BSTnode, *BSTree; void InsertBST( BSTree *bst,int key) {/*插入二叉排序树*/ BSTree s; if(*
第十二章二叉查找树
04-19 1240
二叉查找树的查找（查找某个值、查找最小元素、查找最大元素）、插入、删除操作的最坏时间都为O(h)。构造二叉查找树时采取随机算法，可以让二叉查找树的期望高度为O(lgn)，则前面那些操作的最坏时间就可以为O(lgn)。非常高效的算法。 代码如下： #include using namespace std; struct TreeNode { int key; TreeNode *p;
数据结构---二叉排序树（BST）
爱上在路上
08-10 1198
1、二叉排序树简介 二叉排序树又称“二叉查找树”、“二叉搜索树”。 二叉排序树：或者是一棵空树，或者是具有下列性质的二叉树： 1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 3. 它的左、右子树也分别为二叉排序树。 二叉排序树通常采用二叉链表作为存储结构。中序遍历二叉排序树可得到一个
数据结构实验——树和二叉树子系统
07-31
在本实验“数据结构实验——树和二叉树子系统”中，我们将深入理解二叉树的特性和操作。 首先，实验目的主要涵盖以下几个方面： 1. **理解二叉树特点**：二叉树的每个节点至多有两个子节点，它允许快速查找、插入...
【数据结构】基于树的查找法——二叉排序树（C语言）
weixin_51450101的博客
03-07 2331
二叉排序树又称二叉查找树，它是一种特殊的二叉树。其定义为：二叉排序树或者是一棵空树，或者是具有如下性质的二叉树： ① 若它的左子树非空，则左子树上所有结点的值均均小于根结点的值。 ② 若它的左子树非空，则左子树上所有结点的值均均大于（或大于等于）根结点的值。 ③ 它的左右子树也分别为二叉排序树。
数据结构实验——二叉排序树查找
06-26
实验内容：建立有n个元素的二叉排序树，并在其上进行查找。 实验说明：(1)建立n个元素的二叉树，以链式结构存储，数据元素为整型。(2)在该二叉树上查找某数据，若查找成功则输出成功信息，若查找失败，则插入该数据...
LeetCode题解(1602)：找到二叉树中最近的右侧节点(Python)
长行
11-26 359
题目：原题链接（中等） 标签：树、二叉树、广度优先搜索、深度优先搜索 解法 时间复杂度 空间复杂度 执行用时 Ans 1 (Python) O(N)O(N)O(N) O(N)O(N)O(N) 392ms (13.79%) Ans 2 (Python) O(N)O(N)O(N) O(N)O(N)O(N) 336ms (51.72%) Ans 3 (Python) 解法一（深度优先搜索）： class Solution: def __init__(self):
LeetCode题解之填充二叉树中每个节点的下一个右侧节点
weixin_40409015的博客
06-30 357
完全二叉树的右侧节点 LeetCode原题链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/ 给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。 分析 由于这题处理的二叉树是一棵完全二叉树，所以递归处理的方式也比较简单。主要是使用了递归地自顶向下的
LeetCode 1602. 找到二叉树中最近的右侧节点
Datao_csdn的博客
04-30 786
LeetCode 1602. 找到二叉树中最近的右侧节点 文章目录LeetCode 1602. 找到二叉树中最近的右侧节点题目描述一、解题关键词二、解题报告1.思路分析2.时间复杂度3.代码示例2.知识点总结相同题目 题目描述 给定一棵二叉树的根节点 root 和树中的一个节点 u ，返回与 u 所在层中距离最近的右侧节点，当 u 是所在层中最右侧的节点，返回 null 。   示例 1：   输入：root = [1,2,3,null,4,5,6], u = 4   输出：5 解释：节点 4 所在层中，
【LeetCode】513. Find Bottom Left Tree Value-查找二叉树最左下角元素
aoyan1488的博客
03-24 177
一、描述： 二、思路： 使用队列Queue按序(从左至右)存储每一层的结点，若不是最后一层，则在添加完下一层全部结点后，将上一层结点全部移除，直到最后一层，此时获取队首结点，即为所求； 如何判断当前层是不是最后一层，可以通过二叉树的深度来控制； 故该思路需要两个方法，方法一获取深度，方法二进行每一层结点的压入和移除，用到BFS。 注：代码略长，只是第一次想到的解法 三、代...
二分查找完全二叉树 222. 完全二叉树的节点个数
BLUEsang的博客
06-01 300
222. 完全二叉树的节点个数 给出一个完全二叉树，求出该树的节点个数。 说明： 完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。 示例: 输入: 1 / \ 2 3 / \ / 4 5 6 输出: 6 根据完全二叉树的节点序号，查找该节点 （1）mkroute得到该节点的路径； （2）havenode从root沿着路径到该节
【算法】二叉树获取所有最右节点
u013894623的专栏
08-19 3030
获取一棵二叉树每一层最右边的节点 如 a / \ b c /\ /\ d e f g -&gt; acg a / \ b c /\ / d e f -&gt; acf a ...
找完全二叉树最底层最右边的结点
我的专栏
12-24 2435
题目：用log(n)算法 找完全二叉树最底层最右边的结点 一颗二叉树的总结点其实是知道的，设为N。 如上图，总共有15个结点，那么找15号结点只需从根结点开始，向右--向右--向右。 假设只有14个点，那么向右--向右--向左 假设只有13个结点，那么向右---向左---向右 …… …… 可以找到规律，总结点数即为最后一个结点，也就是我们要找的
LeetCode 1602. 找到二叉树中最近的右侧节点（BFS）
Michael是个半路程序员
08-15 622
文章目录1. 题目2. 解题 1. 题目 给定一棵二叉树的根节点 root 和树中的一个节点 u ，返回与 u 所在层中距离最近的右侧节点，当 u 是所在层中最右侧的节点，返回 null 。 示例 1： 输入：root = [1,2,3,null,4,5,6], u = 4 输出：5 解释：节点 4 所在层中，最近的右侧节点是节点 5。 示例 2： 输入：root = [3,null,4,2], u = 2 输出：null 解释：2 的右侧没有节点。 示例 3： 输入：root = [1], u =
199. 二叉树的右视图 层次遍历，获取当前层最右结点
Hello World程序员的博客
07-08 414
199. 二叉树的右视图 199. 二叉树的右视图 层次遍历，获取当前层最右结点 博客个人https://www.b2bchain.cn/6378.html //给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 // // 示例: // // 输入: [1,2,3,null,5,null,4] //输出: [1, 3, 4] //解释: // // 1 <--- // / \ //2 3 .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值