java数据结构YZP专栏-----二叉树 && 二叉搜索树（二叉排序树，BST）

已于 2024-03-05 11:16:23 修改
阅读量610 收藏 2
点赞数
分类专栏： 编程基础知识 文章标签： java 数据结构
于 2022-04-11 15:42:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/grd_java/article/details/124091563
版权
本文详细介绍了二叉树的基本概念，包括根结点、父结点、子结点、叶子结点和路径等，并探讨了满二叉树和完全二叉树的特性。接着，重点讲解了二叉搜索树，这是一种特殊的二叉树，每个结点的左子结点小于当前结点，右子结点大于当前结点。文章还提供了二叉搜索树的Java实现，包括增、删、改、查操作，并给出了测试案例。通过实例解析，帮助读者更好地理解和运用二叉搜索树。
摘要由CSDN通过智能技术生成
主文章（数据结构的索引目录—进不去就说明我还没写完）
https://blog.csdn.net/grd_java/article/details/122377505
模拟数据结构的网站：https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
源码(码云)：https://gitee.com/yin_zhipeng/data_structures_and_algorithms_in_java.git
二叉搜索树动画演示

请添加图片描述

二叉树

就是一个看起来像一颗树的逻辑内存结构。由很多个结点（节点）组成，但是二叉树规定每个结点最多有两个子结点（两个分叉）
在这里插入图片描述

  1. 根结点：理解为树的根，树的入口，我们必须从根结点，才能找到其它结点
  2. 父结点：当前结点的父结点，比如图中A是B，C的父结点，C是F，G的父结点
  3. 子结点：就是当前结点的子结点，比如C和B是A的子结点
  4. 叶子结点：没有子结点的结点，比如H，E，F，G
  5. 路径：从根结点找到特定结点的路径
  6. 结点权：结点的额外值，有些情况下我们需要对比结点的权值，以判断开销最小的带权路径。
  7. 层（深度）：树的层数，根结点自己算一层，如果它有子结点，子结点算一层，以此类推
  8. 树的高度：共有多少层
  9. 子树：上图中，A是整个二叉树，B是A的左子树，因为B结点是D、H、E结点的根结点。
  10. 森林：有多颗树，就是森林。
  11. 度：表示当前结点是一个什么样的结点。度可以看作结点间的连线。0度，代表这个结点没有子结点，也就是叶子结点。1度，代表这个结点又左或右子树。2度，表示这个结点同时有左右两颗子树
重要的二叉树概念（做题必备特性）

1. 第i层最多有2i-1个结点
2. 二叉树层数为n时，此二叉树最多有2n-1个结点（因为根结点是1个，自己算一层）
3. 叶子结点数为a个,度为2的结点数为b个。则a = b+1，也就是说，叶子结点，永远比度为2的结点多一个

在这里插入图片描述

  1. 满二叉树:除了叶子结点外，其它结点的度都为2。也就是除了最后一层的叶子结点，其它结点都有2个子结点
  1. 结点个数为(2^n)-1（n为层数，2的n次方，减一）
  2. 因为满二叉树，每一层都填满了（连续），所以满二叉树中第 i 层的节点数为 2n-1 个
  3. 深度为 k 的满二叉树必有 2k-1 个节点 ，叶子数为 2k-1
  4. 满二叉树中不存在度为 1 的节点，每一个分支点中都两棵深度相同的子树，且叶子节点都在最底层
  5. 具有 n 个节点的满二叉树的深度为 log2(n+1)----（对数公式都回吧？ax = N，x = logaN）---- 可以算出深度
  1. 完全二叉树：二叉树所有叶子结点，都在倒数第一和倒数第二层。倒数第一层叶子结点左边连续（值不用连续，就是不能缺一块，比如下图14没有左节点81，那么就缺了一块，不是完全二叉树了），倒数第二层叶子结点右边连续。
  1. 注意和满二叉树区分，如果二叉树中除去最后一层节点为满二叉树，且最后一层的结点依次从左到右分布，则此二叉树被称为完全二叉树。
    在这里插入图片描述
  2. X个结点的完全二叉树，深度为(log2X)+1
  3. 第X个元素(X表示二叉树的第几个元素，从0开始)的左子节点为2X+1，右子节点为2X+2，父节点为(X-1)/2.
  4. 总结点个数为total，当前结点下标为X，如果2X>total，则结点没有左子树，否则左子结点为2X，同理，2X+1>total，没有右子树否则2X+1是右子树
  1. 前序遍历：先输出父节点，再遍历左子树和右子树
  2. 中序遍历：先遍历左子树，再输出父节点，再遍历右子树
  3. 后序遍历：先遍历左子树，再遍历右子树，最后输出父节点
如果看不懂上面满二叉树和完全二叉树的区别，可以往下看

在这里插入图片描述

  1. 仔细看满二叉树的编号，数字是一直连续的。它也是一棵完全二叉树。
  2. 而下面的完全二叉树，编号也要连续，并且同一个结点的编号和满二叉树一模一样，这就是完全二叉树。也就是编号连续，并且编号相同的结点和满二叉树相同。但是它的结点个数可能比满二叉树少。
  3. 因此说，满二叉树一定是完全二叉树，但是完全二叉树不一定是满二叉树。因为只要编号是连续的，同一个编号的结点和满二叉树相同，就可以称为是完全二叉树。
  4. 完全二叉树很重要，因为它可以无压力的表示在数组中，因为编号连续（下标）
二叉搜索树（二叉排序树，BST）

二叉树的一种，保留二叉树的概念和每个结点最多两个子结点的特性。但是二叉搜索树有特别的额外规定

  1. 每个结点的左子结点，要比当前结点小，也就是左子树都是更小的
  2. 每个结点的右子结点，要比当前结点大，右子树都是更大的

二叉搜索树的代码实现如下：

  1. 效果
    在这里插入图片描述
  2. 测试方法：我们想让这颗二叉树，能通过泛型，不局限与特定一种数据类型。所以需要用户根据自己使用的数据类型，自定义排序逻辑
    在这里插入图片描述
  3. 树节点
    在这里插入图片描述
  4. 添加结点操作
    在这里插入图片描述
  5. 中序查找和中序遍历，前序和后序，就是代码位置发生了变化而已
    在这里插入图片描述
  6. 删除：分为删除根结点和删除非根结点两种，删除根结点要在二叉树中，非根结点就在树结点类中完成。比较复杂的是，删除结点后，被删除结点的子树如何处理。具体大家直接看代码吧（代码在下面给出），图片这里就理一下逻辑。
    在这里插入图片描述
二叉搜索树
package com.yzpnb.data_structures.tree.binary_search_tree;

import java.util.Comparator;

/**
 * 二叉搜索树
 * 泛用式：使用泛型。泛型无法直接比较，通过用户自定义Comparator实现来进行节点大小比较
 */
public class BinarySearchTree<E> {
    //静态内部类，二叉树结点
    private static class TreeNode<E> {
        TreeNode<E> leftNode;//左子节点，左子树
        E data;//数据域
        TreeNode<E> rightNode;//右子节点，右子树
        //构造方法
        TreeNode(TreeNode<E> leftNode,E data,TreeNode<E> rightNode){
            this.leftNode = leftNode;
            this.data = data;
            this.rightNode = rightNode;
        }
        /**增====需要传入比较规则Comparator，因为我们是泛型。**/
        //根据data元素添加
        public void add(E e, Comparator<? super E> c){
            //compare(o1,o2)正数表示o2>o1,0表示o1=o2，负数表示o2小于o1
            if(c.compare(e,data)>=0){//如果要插入的元素，比如当前结点小，就插入左子树
                //如果当前结点没有左子树，就直接让它当左子树
                if(leftNode == null) leftNode = new TreeNode<E>(null,e,null);
                else leftNode.add(e,c);//否则去左子树继续判断
            }else{//如果比当前结点大，或者和当前结点一样，就插到右子树
                //如果当前结点没有左子树，就直接让它当左子树
                if(rightNode == null) rightNode = new TreeNode<E>(null,e,null);
                else rightNode.add(e,c);//否则去左子树继续判断
            }
        }
        //直接添加结点，代码重复，可以优化
        void add(TreeNode<E> e, Comparator<? super E> c){
            //compare(o1,o2)正数表示o2>o1,0表示o1=o2，负数表示o2小于o1
            if(c.compare(e.data,data)>=0){//如果要插入的元素，比如当前结点小，就插入左子树
                //如果当前结点没有左子树，就直接让它当左子树
                if(leftNode == null) leftNode = e;
                else leftNode.add(e,c);//否则去左子树继续判断
            }else{//如果比当前结点大，或者和当前结点一样，就插到右子树
                //如果当前结点没有左子树，就直接让它当左子树
                if(rightNode == null) rightNode = e;
                else rightNode.add(e,c);//否则去左子树继续判断
            }
        }
        /**删====删除指定非root元素===如果有多个，就删除第一个遇见的，根据要删除的父节点删除。**/
        //如果删除的元素，有左右子节点，就先让左子树上移，然后将右子树添加进入
        public TreeNode<E> deleteOne(E e,Comparator<? super E> c){
            TreeNode<E> parent = null;//为了代码阅读性而定义，要删除结点的父节点
            TreeNode<E> deleted = null;//被删除的节点
            if(leftNode != null){//如果有左子树
                if(leftNode.data.equals(e)){//如果左子节点，恰好是要删除的元素
                    parent = this;//父节点
                    //删除结点，删除结点是父节点的左子树
                    deleted = doDeleteOne(parent,parent.leftNode,true,c);
                    return deleted;//返回被删除结点
                }else{//如果不是左子结点，继续遍历
                    deleted = leftNode.deleteOne(e,c);
                }
            }
            //在左子树找到，直接return，结束递归
            if(deleted != null) return deleted;
            //否则用同样的逻辑找右子树
            if(rightNode != null){
                if(rightNode.data.equals(e)){
                    parent = this;
                    deleted = doDeleteOne(parent,parent.rightNode,false,c);
                    return deleted;
                }else{
                    deleted = rightNode.deleteOne(e,c);
                }
            }
            return deleted;
        }

        /**
         * 负责删除逻辑
         * @param parent 要删除结点的父节点
         * @param deleted 被删除结点
         * @param leftOrRight true表示deleted是parent的leftNode。false表示deleted是parent的rightNode
         * @param c 比较器
         * @return deleted
         */
        public TreeNode<E> doDeleteOne(TreeNode<E> parent,TreeNode<E> deleted,boolean leftOrRight,Comparator<? super E> c){
            //被删除结点
            TreeNode<E> left = deleted.leftNode;//被删除结点的左子树
            TreeNode<E> right = deleted.rightNode;
            //结点反转
            if(leftOrRight){//删除的是parent的左子节点
                parent.leftNode = left; //直接让parent的leftNode指向deleted的左子树
                if(right != null)//如果deleted有右子树
                    parent.add(right,c);//按照逻辑将其插入
            }else{
                parent.rightNode = left;
                if(right != null)
                    parent.add(right,c);
            }
            return deleted;
        }

        /**改====查到指定元素，然后直接改就行**/
        /**查**/
        //中序查找指定元素，先走左，再走当前结点，再走右
        public TreeNode<E> midFind(E e) {
            TreeNode<E> node = null;//用来保存最终结果
            if(leftNode!=null)//如果有左子树，先走左
                node = leftNode.midFind(e);
            //左子树遍历完成
            //判断在左子树是否找到了目标
            if(node != null) return node;
            //没找着就判断当前结点是不是
            if(data.equals(e))
                return this;
            //不是就找右子树
            if(rightNode!=null)
                node = rightNode.midFind(e);
            return node;
        }
        /**遍历**/
        //中序遍历
        public void midPrint() {
            if(leftNode != null) leftNode.midPrint();//先遍历左子树
            System.out.print(" ,"+this);//然后输出自己
            if(rightNode!=null) rightNode.midPrint();//遍历右子树
        }
        @Override
        public String toString() {
            return "TreeNode{" +
                    "data=" + data +
                    '}';
        }
    }
    private TreeNode<E> root;//根结点
    Comparator<? super E> c;
    //构造二叉搜索树
    public BinarySearchTree(Comparator<? super E> c){
        this.c = c;
    }//可以初始不指定根结点
    public BinarySearchTree(TreeNode<E> root,Comparator<? super E> c) {//可以初始化指定root
        this.root = root;
        this.c = c;
    }
    //判断二叉树是否为空
    public boolean isEmpty(){
        return root==null?true:false;
    }
    //如果为空，提示用户
    public boolean isEmptyError(){
        if(isEmpty()) {
            System.out.println("树为空，无法操作！！！");
            return true;
        }else{
            return false;
        }
    }
    /**增====需要传入比较规则Comparator，因为我们是泛型。**/
    //从根结点开始查找正确的插入位置，满足小的在左边，大的在右边，正确的插入位置应该是，找到满足条件且没有子节点的节点，然后当前要插入的节点，成为它的子节点
    public E addNode(E data){
        if(isEmpty()) //如果没有根结点，让新插入的成为根结点。
            root = new TreeNode<>(null,data,null);
        else {
            root.add(data,c);
        }
        return data;
    }
    /**删**/
    public TreeNode<E> deleteOne(E e){
        if(!isEmptyError()) {
            TreeNode<E> deleted = null;
            if(e.equals(root.data)){//根结点需要特殊删除
                deleted = root;
                TreeNode<E> left = root.leftNode,right = root.rightNode;
                if(left != null) {
                    root = left;
                    if(right != null)
                        root.add(right,c);
                }
                else
                    root = right;
            }else{//删除的是非根结点
                deleted = root.deleteOne(e,c);
            }

            if(deleted == null){
                System.out.println("没有找到要删除的节点！！！");
                return deleted;
            }
            return deleted;
        }
        return null;
    }
    /**改====查到指定元素，然后直接改就行**/
    /**查**/
    //中序查找指定元素，先走左，再走当前结点，再走右
    public TreeNode<E> midFind(E e){
        if(!isEmptyError()) {
            TreeNode<E> node = root.midFind(e);
            if( node == null) System.out.println("没找着！！！");
            return node;
        }
        return null;
    }
    /**遍历**/
    //中序遍历先走左，再走当前结点，再走右
    public void midPrint(){
        if(isEmptyError()) return ;
        System.out.print("中序遍历：{");
        root.midPrint();
        System.out.println("}");
    }

}
测试类
package com.yzpnb.data_structures.tree.binary_search_tree;

import java.util.Comparator;

public class Test {
    public static void main(String[] args) {
        BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>(new Comparator<String>() {
            //正数表示o2>o1,0表示o1=o2，负数表示o2小于o1
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        binarySearchTree.addNode("7");
        binarySearchTree.addNode("4");
        binarySearchTree.addNode("5");
        binarySearchTree.addNode("3");
        binarySearchTree.addNode("3");
        binarySearchTree.addNode("7");
        binarySearchTree.addNode("2");
        binarySearchTree.addNode("1");
        binarySearchTree.addNode("3");
        binarySearchTree.midPrint();//中序遍历
        System.out.println("返回data为7的节点："+binarySearchTree.midFind("7"));
        System.out.println("删除data为7的节点"+binarySearchTree.deleteOne("7"));
        binarySearchTree.midPrint();
        System.out.println("删除data为7的节点"+binarySearchTree.deleteOne("7"));
        binarySearchTree.midPrint();
        System.out.println("删除data为4的节点"+binarySearchTree.deleteOne("4"));
        binarySearchTree.midPrint();
        System.out.println("删除data为3的节点"+binarySearchTree.deleteOne("3"));
        binarySearchTree.midPrint();
        System.out.println("删除data为1的节点"+binarySearchTree.deleteOne("1"));
        binarySearchTree.midPrint();
    }
}
2400链接：https://pan.baidu.com/s/1QfV-tzNvWcc8WTgltcWJqA 提取码：73v
03-03
根据提供的文件信息，我们可以梳理出以下相关知识点： ### 1. 材料种类与特性 - **材料种类**：文档中提到了多种材料，包括P2、Mn、SiMn、Cr、CrMo、CrNiMo、Ni、B等。这些材料在不同领域有着广泛的应用，比如机械...
（样本）2024-2030全球与中国超级电容碳市场现状及未来发展趋势 Sample yzp.pdf
10-10
QYResearch是全球知名的大型咨询公司，行业涵盖各高科技行业产业链细分市场，横跨如半导体产业链（半导体设备及零部件、半导体材料、集成电路、制造、封测、分立器件、传感器、光电器件）、光伏产业链（设备、硅料/...
java数据结构YZP专栏-----队列
殷志鹏的博客
02-08 623
java 队列
java数据结构YZP专栏-----数组的底层原理
殷志鹏的博客
02-22 2753
数组原理
java数据结构YZP专栏-----二叉树 && 平衡二叉树（AVL）
殷志鹏的博客
03-06 476
【代码】java数据结构YZP专栏-----二叉树 && 平衡二叉树（AVL）
java数据结构YZP专栏-----链表
殷志鹏的博客
02-22 631
链表数据结构
java数据结构YZP专栏版-----堆栈
殷志鹏的博客
01-08 640
java堆栈
java数据结构YZP专栏版-----主目录-----持续更新
殷志鹏的博客
03-03 278
本文相当于目录方便快速检索内容，没有实际内容，只做索引
java JVM 学习总结YZP专栏---Java技术的未来
殷志鹏的博客
03-02 1069
java JVM 学习总结YZP专栏—主目录—持续更新(进不去说明我没写完)：https://blog.csdn.net/grd_java/article/details/123210715 Oracle的黑科技Graal VM 2018年4月，Oracle Labs新公开一项黑科技：Graal VM。它的口号是“Run Programs Faster Anywhere” 被官方称为“Universal VM”和“Poly glot VM”，在HotSopt虚拟机基础上增强而...
java JVM 学习总结YZP专栏---Java内存和内存溢出
殷志鹏的博客
03-04 677
java JVM 学习总结YZP专栏—主目录—持续更新(进不去说明我没写完)：https://blog.csdn.net/grd_java/article/details/123210715 文章目录1. 运行时数据区1.1 程序计数器（Program Counter Register）1.2 Java虚拟机栈（Java Virtual Machine Stack）1.3 本地方法栈(Native Method Stacks)1.4 Java堆1.5 方法区（Method Area）1.6 方...
java JVM 学习总结YZP专栏---历史上的Java虚拟机有哪些
殷志鹏的博客
03-01 2523
java JVM 学习总结YZP专栏—主目录—持续更新(进不去说明我没写完)：https://blog.csdn.net/grd_java/article/details/123210715 文章目录1.1 虚拟机始祖：Sun Classic/Exact VM1.2 武林盟主：HotSpot VM1.3 小家碧玉：Mobile/Embedded VM1.4 天下第二：BEA JRockit/IBM J9 VM1.5 软硬合璧：BEA Liquid VM/Azul VM1.6 挑战者：Apach...
（样本）2024-2030全球与中国高功率封装纳米烧结银市场现状及未来发展趋势 Sample yzp.pdf
07-31
QYResearch是全球知名的大型咨询公司，行业涵盖各高科技行业产业链细分市场，横跨如半导体产业链（半导体设备及零部件、半导体材料、集成电路、制造、封测、分立器件、传感器、光电器件）、光伏产业链（设备、硅料/...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 610
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1110
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 763
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 435
默认对常规Session的理解和使用，如何使用Set-Cookie。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 252
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
信息学科平台系统开发：基于Spring Boot的最佳实践
2401_85761762的博客
11-02 1000
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。本系统具有易操作、易管理、交互性好的特点，在操作上是非常简单的，因此在操作上具有很高的可行性。（2）该完整内容全面，管理方便可以及时的全面的处理各种错误，异常，这样避免了很多因用户的马虎操作而出现的失误，其操作方便，用户界面友好，能够上网的人都可以很好的进行操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

殷丿grd_志鹏

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

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

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

打赏作者

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

抵扣说明：

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

余额充值