数据结构与算法:树 二叉排序树(BST) (八)

已于 2022-07-13 14:57:07 修改
阅读量239 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java 数据结构 BST 树
于 2022-07-07 11:24:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44819566/article/details/125655449
版权

Tips: 采用java语言,关注博主,底部附有完整代码

工具:IDEA

本系列介绍的是数据结构: 树

这是第8篇目前计划一共有11篇:

  1. 二叉树入门
  2. 顺序二叉树
  3. 线索化二叉树
  4. 堆排序
  5. 赫夫曼树(一)
  6. 赫夫曼树(二)
  7. 赫夫曼树(三)
  8. 二叉排序树(BST)本篇
  9. 平衡二叉排序树AVL
  10. 2-3树,2-3-4树,B树 B+树 B*树 了解
  11. 数据结构与算法:树 红黑树 (十一)

敬请期待吧~~

基本介绍

二叉排序树(Binary sort tree) 又叫做 二叉搜索树(binary search tree) ,是树形结构中的一种

定义:

  • 非叶子结点外 他的每个左子结点都比当前结点小
  • 非叶子结点外 他的每个右子结点都比当前结点大
  • 如果一颗树只有树根,那么这也是 BST树

二叉排序树

先来看一张BST树:

image-20220707094942534

这是比较理想的情况,可以看出这棵树符合BST的定义

结点定义

public class SortTreeNode {

    int value;

    // 左子结点
    SortTreeNode leftNode;

    // 右子结点
    SortTreeNode rightNode;

    public SortTreeNode(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "SortTreeNode{" +
                "value=" + value +
                '}';
    }
  
     // region TODO 中序遍历
    public void show() {
        if (leftNode != null) {
            leftNode.show();
        }
        System.out.println(this);

        if (rightNode != null) {
            rightNode.show();
        }
    }
    // endregion

    // region TODO 层序遍历
    public void showFloor() {
        Queue<SortTreeNode> queue = new LinkedList<>();
        queue.add(this);
        int index = 0;
        while (!queue.isEmpty()) {
            SortTreeNode removeNode = queue.remove();

            System.out.println("index" + (index++) + "层序遍历:" + removeNode);
            if (removeNode.leftNode != null) {
                queue.add(removeNode.leftNode);
            }
            if (removeNode.rightNode != null) {
                queue.add(removeNode.rightNode);
            }
        }
    }
    // endregion
}

这里非常简单,就是一个很普通的结点类

添加结点

思路:

  • 如果要添加的结点比当前结点大,添加到右子结点上
    • 右子结点 == null , 直接添加到右子结点
    • 右子结点 != null, 进行下一轮递归
  • 如果要添加的结点比当前结点小,添加到左子结点上
    • 左子结点 == null, 直接添加到左子结点上
    • 左子结点 != null,进行下一轮递归

添加的代码非常简单:

# SortTreeNode.java
// 添加结点  
public void add(SortTreeNode node) {
    if (node == null) {
        return;
    }

    // 如果传入的结点 <= 当前结点
    // 说明当前结点应该存放在左子结点上
    if (node.value <= value) {
        // 如果左子结点为null 说明是叶子结点 直接存放即可
        if (leftNode == null) {
            leftNode = node;
        } else {
            leftNode.add(node);
        }
    }
    // 如果传入的结点 >= 当前结点
    // 说明当前结点应该存放在右子结点上
    if (node.value >= value) {
        // 如果左子结点为null 说明是叶子结点 直接存放即可
        if (rightNode == null) {
            rightNode = node;
        } else {
            rightNode.add(node);
        }
    }
}

添加完整流程图:

二叉排序树add

如果二叉排序树成功的话,配合中序遍历,正好是有序的!

搜索结点

搜索结点分为2种情况:

  • 搜索当前结点
  • 搜索当前结点的父结点

搜索当前结点好理解, 为什么要搜索当前结点的父结点呢?

这里是为了删除结点做准备

因为删除结点得通过 parent.leftNode = null || parent.rightNode = null 来进行删除

这样删除的是指针对象

而不是通过 currentNode.leftNode = null || currentNode .rightNode 来进行删除

这样删除只是吧一个变量删除了,并没有任何意义!!

搜索当前结点

思路和添加结点思路有异曲同工之妙:

  • 如果当前结点 > 需要查找的结点,那么就去右子结点上找
  • 如果当前结点 < 需要查找的结点,那么就去左子结点上找

理想状态下和二分查找很想!

# SortTreeNode.java

// @param return: 没有找到返回null
public SortTreeNode search(int value) {
//        System.out.println("search" + this.value + "\tvalue" + value);

        // 需要找的结点 = 如果当前结点
        if (value == this.value) {
            return this;
        } else if (value < this.value) {
            // 继续找左子结点
            if (leftNode != null) {
                return leftNode.search(value);
            }
        } else {
            // 继续找右子结点
            if (rightNode != null) {
                return rightNode.search(value);
            }
        }
        return null;
    }

搜索父结点

搜索父结点有所不同,以上面提到的 BST树来举例:

image-20220707094942534

可以看出, 8结点 和 11 结点的父结点都是10

来看看完整代码:

# SortTreeNode.java
  
public SortTreeNode searchParent(int value) {
    // 左子结点 != null 并且左子结点 == 当前结点
    boolean isLeftCompare = (leftNode != null && leftNode.value == value);
    boolean isRightCompare = (rightNode != null && rightNode.value == value);

    // 如果左子结点 或者右子结点相同 说明找到了父结点
    if (isLeftCompare || isRightCompare) {
        return this;
    } else if (value < this.value && leftNode != null) {
        // 当前结点 < 需要查找的结点  并且 左子结点不为null 继续向左找
        return leftNode.searchParent(value);
    } else {
        if (rightNode != null) {
            return rightNode.searchParent(value);
        }
    }
    return null;
}

这段代码细品一下还是不难的.

删除结点

删除结点分为3种情况:

  • 删除叶子结点
  • 删除只有1个结点的结点
  • 删除有2个结点的结点
删除叶子结点直接删除image-20220707101648571
删除只有1个结点的结点让删除结点的子结点代替删除结点位置image-20220707101841064
删除有2个结点的结点找到删除结点的后继结点代替删除即结点位置image-20220707101911804

删除叶子结点

// 删除结点
public void del(int value) {
    // TODO 当前结点
    SortTreeNode searchNode = search(value);

    if (searchNode == null) {
        System.out.println("没有找到结点");
        return;
    }

    // TODO 当前结点的父结点
    SortTreeNode searchParentNode = searchParent(value);
  
    // TODO 删除叶子结点
  	if (searchNode.leftNode == null && searchNode.rightNode == null) {
      // 如果左子结点和当前结点相同 那么就删除左子结点
      if (searchParentNode.leftNode == searchNode) {
          searchParentNode.leftNode = null;
      }
      // 反之删除右子结点
      if (searchParentNode.rightNode == searchNode) {
          searchParentNode.rightNode = null;
      }
    }
}

不好理解可以看着图来理解:

当前结点 是 2

父结点 是 3

image-20220707101648571

删除只有一个子结点

public void del(int value) {

    // TODO 当前结点
    SortTreeNode searchNode = search(value);

    if (searchNode == null) {
        System.out.println("没有找到结点");
        return;
    }

    // TODO 当前结点的父结点
    SortTreeNode searchParentNode = searchParent(value);
  
    // TODO 删除叶子结点
    if (searchNode.leftNode == null && searchNode.rightNode == null) {
      	....
    } else if (searchNode.leftNode == null) {
        // TODO 删除只有一个叶子结点
        // 如果左子结点为null 说明右子结点不为null

        // 如果当前是左子结点
        if (searchParentNode.leftNode == searchNode) {
          // 那么就让左子结点 = 当前元素的右子结点 达到删除的目的
          searchParentNode.leftNode = searchNode.rightNode;
        }
        if (searchParentNode.rightNode == searchNode) {
          searchParentNode.rightNode = searchNode.rightNode;
        }
    } else if (searchNode.rightNode == null) {
        // TODO 删除只有一个叶子结点
        // 和上边同理
        if (searchParentNode.leftNode == searchNode) {
          searchParentNode.leftNode = searchNode.leftNode;
        }
        if (searchParentNode.rightNode == searchNode) {
          searchParentNode.rightNode = searchNode.leftNode;
        }
      }
}

还是同理,逻辑不清晰的看图说话

当前结点是5

父结点是3

image-20220707101841064

删除有2个结点的结点

如果删除2个结点的结点,那么他是通过后继结点来代替当前结点位置

思路:

  • 寻找后继结点, 按照中序遍历的思路,后继结点在当前结点的右子结点的最左侧
  • 找到后继结点后吧后继结点删除掉,然后让当前结点的值 = 后继结点即可

tips: 这里其实说白了没有进行删除,只是进行了值的替换,达到了“删除”的效果,具体删除的只是后继结点

假设当前删除的元素是3,那么就找到他的后继结点

上边也说过,后继结点是当前结点的右子结点的最左边

这里当前结点只有右子结点,所以后继结点就是5

image-20220707105327105

然后在吧5删除掉,就变成了删除一个结点的结点,就变成了这样

image-20220707105605153

最后将后继结点的值替换到当前结点上,就达到了删除的效果

image-20220707105657287

思路也很简单,那就来看看完整代码:


public void del(int value) {

  // TODO 当前结点
  SortTreeNode searchNode = search(value);

    if (searchNode == null) {
      System.out.println("没有找到结点");
      return;
    }

    // TODO 当前结点的父结点
    SortTreeNode searchParentNode = searchParent(value);

    // 左子结点和右子结点为null 说明是叶子结点
    // TODO 删除叶子结点
    if (searchNode.leftNode == null && searchNode.rightNode == null) {
      ....
    } else if (searchNode.leftNode == null) {
      // TODO 删除只有一个叶子结点
      .....
    } else if (searchNode.rightNode == null) {
      // TODO 删除只有一个叶子结点
      // 和上边同理
      .....
    } else {
      // TODO 左子结点和右子结点都有值!

      // 此时结点为要删除结点的 后继结点
      // 后继结点在右子结点的最左侧
      SortTreeNode lastNode = delDoubleTree(searchNode.rightNode);

      // 当前结点 = 后继结点即可
      searchNode.value = lastNode.value;
    }
}

// 删除有两个结点的树
public SortTreeNode delDoubleTree(SortTreeNode node) {
    SortTreeNode temp = node;

    // 寻找到后继结点
    while (temp.leftNode != null) {
        temp = temp.leftNode;
    }

    // 删除当前最小值
    del(temp.value);
    // 返回当前结点
    return temp;
}

执行到这里,删除结点就完事了!

理想状态和不理想状态

理想状态

上边提到的这颗树就是比较理想状态,因为左子结点和右子结点基本一样高

image-20220707094942534

这样的话删除,搜索,的速度还是很可观的

不理想状态

有理想状态肯定有不理想状态, 那么非常极端的不理想状态就是这样:

image-20220707110424357

可以看出,这样的话感觉像是链表一样,如果要搜索,删除结点也很不友好…

优点:

  • 比较基础的树结构,能够通过中序遍历进行排序

  • 代码比较简单

  • 理想状态下效果还可以

缺点:

  • 如果不理想状态,效果极差

这里就引出了下一篇 (AVL 平衡二叉树)!,AVL树就是为了解决这种很奇怪的现象

调用:

public static void main(String[] args) {

        int[] tempInts = {10, 8, 3, 11, 12, 5, 6, 2};

        // 规则: 左子结点 >= 当前结点 > 右子结点

        SortTreeNode root = new SortTreeNode(7);
        for (int tempInt : tempInts) {
            root.add(new SortTreeNode(tempInt));
        }

        System.out.println("length" + tempInts.length);

//        test(root);

        // 层序: 7 3 10 2 5 8 11 6 12
        // 中序: 2 3 5 6 7 8 10 11 12
        System.out.println("原始数据");
        root.show();

        root.del(7);
        System.out.println("删除后®");
        root.show();
    }

这里就偷个懒没有写tree类,直接操作的是rootNode… 大家别学我,还是规范一点比较好 @__@

完整代码

原创不易,您的点赞就是对我最大的支持!

其他树结构文章:

  1. 二叉树入门
  2. 顺序二叉树
  3. 线索化二叉树
  4. 堆排序
  5. 赫夫曼树(一)
  6. 赫夫曼树(二)
  7. 赫夫曼树(三)
  8. 二叉排序树(BST)本篇
  9. 平衡二叉排序树AVL
  10. 2-3树,2-3-4树,B树 B+树 B*树 了解
  11. 数据结构与算法:树 红黑树 (十一)
s10g
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
8.4 使用二叉树的排序算法*8.5 小结
zhengheda的博客
07-02 127
8.4 使用二叉树的排序算法*8.5 小结
数据结构与算法-BST(二叉搜索树)、AVL树(平衡二叉树)
weixin_45639955的博客
02-12 331
1二叉查找树 1.1特点 任意节点的左子树不空, 则左子树上所有节点的key均小于它的根节点的key 任意节点的右子树不空, 则右子树上所有节点的key均大于它的根节点的key 任意节点的左,右子树也分别为二叉查找树 没有key相等的节点 二叉查找树进行中序遍历，可以得到一个递增的有序序列 1.2结构 struct Node { int key; struct Node* l...
搜索二叉树的查找，插入与删除操作图解
didi1663478999的博客
04-12 1574
二叉搜索树 1.二叉搜索树的概念 二叉搜索树又称二叉排序树，或者是一颗空树，或者是具有以下性质的二叉树： （1）若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 （2）若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 （3）它的左右子树也分别为二叉搜索树 ={5，3，4, 1，7, 8，2, 6，0, 9} 顺便回顾一下二叉树前中后序遍历是怎么遍历的 前序（根左右）：5...
【数据结构与算法】——二叉排序树
秋雨绵绵
06-13 905
🎄：CSDN的小伙伴们大家好，今天跟大家分享一个二叉树的应用案例——二叉排序树。如果这篇文章对你有用，麻烦给我点个小赞以示鼓励吧🎄
数据结构——二叉排序树（BST）
木易三水良
02-25 764
基本介绍： 二叉排序树BST（Binary Sort(Search) Tree）,对于二叉排序树的任何一个非叶子节点要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点，如果二叉排序树中存在节点值相同的时候，示例代码中给出的获取节点的方法，只会返回第一个相同值的节点，这就致使在进行删除操作的时候会报栈溢出（StackOve...
数据结构与算法：树与二叉树（python实现二叉树）
Dreaming5498的博客
07-18 328
文章目录树与树算法树的定义，特点树的术语二叉树二叉树的性质二叉树的分类树的存储与表示节点的结构：二叉树实现二叉树的遍历广度优先遍历(层次遍历)深度优先遍历先序遍历中序遍历后序遍历 树与树算法 树的定义，特点 树(英语:tree)是一种抽象数据类型(ADT)或是实作这种抽象数据类型的数据结构,用来模拟具有树状结构性质的数据集合。 它是由n(n>=1)个有限节点组成一个具有层次关系的集合。把它叫...
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键性质： 1. 左子树上的所有节点的值都小于当前节点的值。 2. 右子树上的所有节点的值都大于当前...
数据结构课程设计 二叉排序树与平衡二叉排序树
05-29
在数据结构的学习中，二叉排序树（Binary Search Tree，BST）是一种常见的树形数据结构，它具有查找、插入和删除等操作的高效性。在这个课程设计中，我们将重点探讨如何利用二叉链表作为存储结构来实现二叉排序树，...
数据结构实验--基于二叉排序树的商品查询系统
10-16
在数据结构领域，二叉排序树是一种非常重要的数据结构，它能够有效地支持查找、插入和删除等操作。本实验是关于基于二叉排序树的商品信息查询系统的设计与实现，主要目标是让学生深入理解并熟练运用二叉排序树的相关...
数据结构实验之二叉排序树
06-03
二叉排序树（Binary Search Tree，BST），是数据结构领域中一种重要的树形数据结构，它的每个节点都包含一个键值、一个指向左子树的指针和一个指向右子树的指针。在二叉排序树中，任何节点的左子树只包含键值小于该...
Promise 详解（原理篇）
最新发布
山重水复疑无路，柳暗花明又一村。
07-20 477
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 557
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 979
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 127
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1030
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java实验2
qq_64727229的博客
07-16 531
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 446
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
"数据结构实验报告：二叉排序树BST和平衡二叉树AVL构造
实验一 二叉树的应用：二叉排序树 BST 和平衡二叉树 AVL 的构造 一、实验学时：4 二、实验内容和目的： 树型结构是一类重要的非线性数据结构。其中以树和二叉树最为常用，直观看来，树是以分支关系定义的层次结构...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

s10g

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值