我要种一棵BST(二叉排序树)

最新推荐文章于 2024-08-31 10:53:27 发布
最新推荐文章于 2024-08-31 10:53:27 发布
阅读量684 收藏 26
点赞数 52
分类专栏： 数据结构与算法 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/joelib/article/details/124116947
版权
本文深入探讨了二叉排序树（BST）的概念，包括其定义、创建思想、节点添加和删除的详细过程。通过代码实现展示了节点类和BST类的设计，并对删除操作的三种情况进行了详细分析，包括叶子节点、单子树节点和双子树节点的删除。此外，还提供了完整的代码示例，帮助读者理解BST的操作流程。
摘要由CSDN通过智能技术生成

  BST(二叉排序树)

从BST的概述,BST的创建思想,BST的代码实现与分析,BST的图解展开阐述

若有疏漏,欢迎指出

博主空间https://blog.csdn.net/JOElib?type=blogAVL树https://joelib.blog.csdn.net/article/details/124072495?spm=1001.2014.3001.5502多叉树和图 https://joelib.blog.csdn.net/article/details/124042140?spm=1001.2014.3001.5502

目录

BST的概述🐼 

BST的定义:🦁

BST的样子:🦁

BST的创建思想🐼  

BST的创建🦁

BST节点的删除🦁 

1.叶子节点的删除😀

2.非叶子节点且有一棵子树的删除😀

3.非叶子节点且有两颗子树的删除😀 

代码实现与分析🐼 

节点类:😶‍🌫️

1.创建一个节点类🐻 

代码分析:🐨

2.创建一个添加节点的方法🐻  

代码分析:🐨 

3.删除节点的前置操作 😶‍🌫️

3.1创建一个找到待删除节点的方法🐻 

代码分析:🐨

3.2找到待删除节点的父节点🐻

代码分析:🐨 

3.3创建一个中序遍历的方法(好验证是否写错)🐻 

代码分析:🐨 

BST类:😶‍🌫️ 

4.创建一个BST类🐻

代码分析:🐨 

5.创造对应的表层方法去调用底层方法🐻 

代码分析:🐨 

6.删除节点的第三个前置方法(获取左子树最大值)🐻 

代码分析:🐨

7.删除方法(根本)的讲述🐻 

代码分析:🐨 

删除操作的图解🐼

完整代码🐼  

结论🐼

BST的概述🐼  

BST的定义:🦁

  • BST要求任何的非叶子节点的左子节点的权值要求比当前节点的权值要小,且右子节点的权值要比当前节点的权值要大
  • 如果父节点的权值和子节点的权值相等,可以任意放在左子节点或者是右子节点,博主代码实现默认放在右子节点 

BST的样子:🦁

BST的创建思想🐼  

BST的创建🦁

  1. 用待添加的节点与当前节点进行比较,如果比当前节点大,则判断左子树
    1. 若右子树为空,则将新的节点直接挂上去,否则向右子树递归添加
  2. 如果比当前节点小,则判断左子树
    1. 若左子树为空,则将新的节点直接挂上去,否则向左子树递归添加 

BST节点的删除🦁 

1.叶子节点的删除😀

  1. 找到待删除的节点target
  2. 找到待删除节点的父节点parent
  3. 判断待删除节点是父节点的左子节点还是右子节点
  4. 置空

2.非叶子节点且有一棵子树的删除😀

  1. 找到待删除的节点target
  2. 找到待删除节点的父节点parent
  3. 判断待删除节点是父节点的左子节点还是右子节点
  4. 判断待删除节点有左子树还是右子树
  5. 根据情况赋值

3.非叶子节点且有两颗子树的删除😀 

  1. 找到待删除的节点target
  2. 在待删除节点的右子树中找一个最小的节点(或在待删除节点的左子树中找一最大的节点)
  3. 将找到的节点的值赋值给待删除节点
  4. 将该节点删除

代码实现与分析🐼 

节点类:😶‍🌫️

1.创建一个节点类🐻 

public class Node {
    // 节点对应的权
    public int value;
    // 左子节点
    public Node left;
    // 右子节点
    public Node right;
    
    // 构造方法
    public Node(int value) {
        this.value = value;
    }

    // 重写的toString()方法.便于输出
    public String toString() {
        return value + "";
    }
}

代码分析:🐨

  •  代码所示

2.创建一个添加节点的方法🐻  

// node是待添加的节点
public void add(Node node) {
        if (node == null) {
            return;
        }
        if (node.value >= this.value) {
            if (right != null) {
                right.add(node);
            }else {
                right = node;
            }
        }else {
            if (left != null) {
                left.add(node);
            }else {
                left = node;
            }
        }
    }

代码分析:🐨 

  • 首先,我们先要校验待添加节点是否为空,若为空,则直接结束方法
  • 根据BST的创建思想得出来以下的代码 

3.删除节点的前置操作 😶‍🌫️

3.1创建一个找到待删除节点的方法🐻 

// value是待删除节点的权值   
 public Node searchTarget(int value) {
        if (this.value == value) {
            return this;
        }else if (value >= this.value) {
            return this.right != null?right.searchTarget(value):null;
        }else {
            return this.left != null?left.searchTarget(value):null;
        }
    }

代码分析:🐨

  •  首先,我们先比较当前节点的权值是否等于待删除节点的权值
    • 若等于,说明当前节点是待删除的节点,返回当前节点
    • 若不等于,则走一下步骤
  • 判断当前节点的权值与待删除节点的权值的大小
    • 若待删除节点的权值大于当前节点的权值,说明,待删除节点一定在右子树上(BST特征),否则一定在左子树上
    • 再判断右子树(左子树)是否为空,若为空说明找不到待删除的节点,返回null
    • 若右子树不为空,则往右子(左子树)树递归查找
  • 注意:这里运用到了三目操作符,原理如下:
    • 先判断this.right != null这个条件,这个条件若为true,则执行right.searchTarget(value)这个表达式,否则执行null
    • 三目操作符中,一个表达式的执行,该表达式的结果作为整个三目操作符表达式的结果

3.2找到待删除节点的父节点🐻

public Node searchParent(int value) {
        if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
            return this;
        } else if(value >= this.value) {
            return this.right != null?right.searchParent(value):null;
        }else {
            return this.left != null?left.searchParent(value):null;
        }
    }

代码分析:🐨 

  • 当前方法与找到待删除节点的方法基本一致,需要改变的是以下节点
  • 因为找待删除节点的父节点,所以判断当前节点的左子节点或右子节点是否为待删除的节点
  • 若是,则之间返回当前节点,当前节点就是我们想要的父节点,否则递归查找
  • 注意:在访问左子节点和右子节点的时候一定要判断其是否为空,否则会空指针异常

3.3创建一个中序遍历的方法(好验证是否写错)🐻 

    public void infixPrint() {
        if (this.left != null) {
            left.infixPrint();
        }
        System.out.println(this);
        if (this.right != null) {
            right.infixPrint();
        }
    }

代码分析:🐨 

  • 略:如有需要,可以翻翻博主之前的博客,里面有详细的解释 

BST类:😶‍🌫️ 

4.创建一个BST类🐻

public class BinarySortTree {
    // root是根节点属性
    public Node root;
    // 利用JVM默认提供的无参构造即可满足要求
}

代码分析:🐨 

  • 如代码所示 

5.创造对应的表层方法去调用底层方法🐻 

    public Node searchTarget(int value) {
        if (root == null) {
            return null;
        }else {
            return root.searchTarget(value);
        }
    }

    public Node searchParent(int value) {
        if (root == null) {
            return null;
        }else {
            return root.searchParent(value);
        }
    }
    public void infixPrint() {
        if (root != null) {
            root.infixPrint();
        }
    }
    public void add(Node node) {
        if (root == null) {
            root = node;
            return;
        }
        root.add(node);
    }

代码分析:🐨 

  • 分析上述代码得,都要校验以下根节点是否为空,若为空,这些方法都没有意义,直接结束返回即可

6.删除节点的第三个前置方法(获取左子树最大值)🐻 

    // node为当前节点(即左子树的根节点)
    public int searchLeftMax(Node node) {
        var cur = node;
        while (cur.right != null) {
            cur = cur.right;
        }
        var res = cur.value;
        del(cur.value);
        return res;
    }

代码分析:🐨

  •  将当前节点放入辅助引用cur
  •  根据BST树的特征,右子节点的值一定比当前节点的值大,所以我们一直往右子树去找即可,即得 出了对应的while循环及其循环体
    • 注意:我们要找到最大节点的父节点,否则无法删除,故cur.right != null
  •  当while循环结束后,找到了最大的节点的父节点,将其右子节点的值保存下来,放入res
  •  调用del方法,删除该节点(接下来解释),再将值返回即可

7.删除方法(根本)的讲述🐻 

    // value 待删除节点的权值
    public void del(int value) {
        if (root == null) {
1           return;
        }
2       Node targetDel = searchTarget(value);
3       if (root.left == null && root.right == null && root == targetDel) {
            root = null;
            return;
        }
4       Node parent = searchParent(value);
5       if (targetDel.right == null && targetDel.left == null) {
6           if (parent.left != null && parent.left == targetDel) {
                parent.left = null;
7           }else if(parent.right != null && parent.right == targetDel) {
                parent.right = null;
            }
8       }else if (targetDel.left != null && targetDel.right != null) {
            targetDel.value = searchLeftMax(targetDel.left);

9       }else {
10           if (parent != null) {
11               if (parent.left != null && parent.left == targetDel) {
12                   if (targetDel.left != null) {
                        parent.left = targetDel.left;
13                   }else {
                        parent.left = targetDel.right;
                    }
14              }else if (parent.right != null && parent.right == targetDel) {
15                  if (targetDel.left != null) {
                        parent.right = targetDel.left;
16                  }else {
                        parent.right = targetDel.right;
                    }
                }
17          }else {
18              if (targetDel.right != null) {
                    root = root.right;
19              }else {
                    root = root.left;
                }
            }
        }
    }

代码分析:🐨 

  • 注意:由于代码太长,我们分模块展开阐述,注意代码中的标号
  • 1.先校验根节点是否为空,若为空,则直接结束方法
  • 以下为创建思想的步骤
  • 2.找到待删除节点
  • 3.(特殊情况)我们先判断以下是否只有根节点,若只有根节点且根节点是我们想要删除的节点,则将root置为null并结束方法
    • 原因:若只有根节点的时候,我们是无法得出其父节点(即根节点没有父节点),当此刻只有根节点时,执行以下方法会导致空指针异常(在5发生)
  • 4.找到当前节点的父节点
  • 5.判断,若当前节点的左子节点和右子节点都为空,说明是叶子节点
    • 判断该待删除节点是父节点的左子节点还是右子节点(对应着6,7),判断出来后直接将其置空即可
  • 8.判断,若当前节点的左子节点和右子节点都不为空,说明是非叶子节点且有两棵子树
    • 将当前节点的权值修改成调用searchLeftMax方法的返回值,就可以完成思路
  • 9.否则,只剩下最后一种情况,即待删除节点只有一颗子树的情况
    • 10.因为有可能删除根节点,而根节点又没有父节点,所以我们先要排除影响,有这个if
  • 11.当父节点的左子节点不为空(有可能为空,不加可能会空指针异常),且父节点的左子节点是待删除节点时
    • 12.再判断待删除节点的左子树是否为空,若不为空,则执行parent.left = target.left
    • 13.否则待删除节点有右子树,则执行parent.right = target.left
    • 注意(进入里面判断的前提是必须有一棵子树)
  • 14,15,16同理得
  • 17.因为进入了9说明至少有一棵子树
    • 18.当根节点的右子树不为空时,删除后右子树的根节点就是新的根节点,所以root.right = root
    • 19.同理得
  • 注意:为什么8里面也不进行等效操作,因为8不涉及父节点的操作,所以没有必要

删除操作的图解🐼

完整代码🐼  

package datastructure.chapter04.tree.binarysorttree;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: asus
 * Date: 2022-04-01
 * Time: 19:46
 */
public class Node {
    public int value;
    public Node left;
    public Node right;

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

    public String toString() {
        return value + "";
    }

    public void add(Node node) {
        if (node == null) {
            return;
        }
        if (node.value >= this.value) {
            if (right != null) {
                right.add(node);
            }else {
                right = node;
            }
        }else {
            if (left != null) {
                left.add(node);
            }else {
                left = node;
            }
        }
    }

    public Node searchTarget(int value) {
        if (this.value == value) {
            return this;
        }else if (value >= this.value) {
            return this.right != null?right.searchTarget(value):null;
        }else {
            return this.left != null?left.searchTarget(value):null;
        }
    }

    public Node searchParent(int value) {
        if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
            return this;
        } else if(value >= this.value) {
            return this.right != null?right.searchParent(value):null;
        }else {
            return this.left != null?left.searchParent(value):null;
        }
    }

    public void infixPrint() {
        if (this.left != null) {
            left.infixPrint();
        }
        System.out.println(this);
        if (this.right != null) {
            right.infixPrint();
        }
    }
}
package datastructure.chapter04.tree.binarysorttree;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: asus
 * Date: 2022-04-01
 * Time: 19:46
 */
public class BinarySortTree {
    public Node root;
    public void add(Node node) {
        if (root == null) {
            root = node;
            return;
        }
        root.add(node);
    }

    public Node searchTarget(int value) {
        if (root == null) {
            return null;
        }else {
            return root.searchTarget(value);
        }
    }

    public Node searchParent(int value) {
        if (root == null) {
            return null;
        }else {
            return root.searchParent(value);
        }
    }

    public void del(int value) {
        if (root == null) {
            return;
        }
        Node targetDel = searchTarget(value);
        if (root.left == null && root.right == null && root == targetDel) {
            root = null;
            return;
        }
        Node parent = searchParent(value);
        if (targetDel.right == null && targetDel.left == null) {
            if (parent.left != null && parent.left == targetDel) {
                parent.left = null;
            }else if(parent.right != null && parent.right == targetDel) {
                parent.right = null;
            }
        }else if (targetDel.left != null && targetDel.right != null) {
            targetDel.value = searchLeftMax(targetDel.left);

        }else {
            if (parent != null) {
                if (parent.left != null && parent.left == targetDel) {
                    if (targetDel.left != null) {
                        parent.left = targetDel.left;
                    }else {
                        parent.left = targetDel.right;
                    }
                }else if (parent.right != null && parent.right == targetDel) {
                    if (targetDel.left != null) {
                        parent.right = targetDel.left;
                    }else {
                        parent.right = targetDel.right;
                    }
                }
            }else {
                if (targetDel.right != null) {
                    root = root.right;
                }else {
                    root = root.left;
                }
            }
        }
    }

    public int searchLeftMax(Node node) {
        var cur = node;
        while (cur.right != null) {
            cur = cur.right;
        }
        var res = cur.value;
        del(cur.value);
        return res;
    }

    public void infixPrint() {
        if (root != null) {
            root.infixPrint();
        }
    }
}

结论🐼

        BST树创建起来还是很简单的,主要是删除操作具有一定的难度,涉及到的思想和步骤有点多,我来总结以下几点

        1.删除操作的三大情况

        2.每种情况的算法步骤

        3.特殊情况的考虑

        4.BST的创建

        🚇最后一篇:堆排序

爪哇土著、JOElib
关注
  • 52
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 75
    评论
专栏目录
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
3.左、右子树本身又各是一棵二叉排序树。 平衡二叉树（Balanced Binary Tree）又被称为AVL树。具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。构造与...
二叉排序树（BST）创建详解之C语言版
sunnyoldboy博客
10-03 7230
二叉排序树（Binary Sort Tree或 Binary Search Tree）又称二叉查找树，可以用来实现数据的快速查找，也方便数据的插入、删除等工作，因此适用于数据的动态查找。
数据结构-二叉排序树（BST树）
理科男同学
11-15 9836
1，二叉排序树介绍 二叉排序树（Binary Sort Tree）或者是一颗空树；或者是具有如下性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树又分别为二叉排序树。 显然二叉排序树的定义是一个递归形式的定义，所以后面景禹要讲的插入、查找和删除都是基于递归的形式。特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 1.1，二叉排序树的构建 假设我们有初始的无序...
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键性质： 1. 左子树上的所有节点的值都小于当前节点的值。 2. 右子树上的所有节点的值都大于当前...
写一算法,判断一棵二叉树是否是一棵二叉排序树。
07-15
根据给定的文件信息，我们将深入探讨如何通过不同的方法来判断一棵二叉树是否为二叉排序树（Binary Search Tree, BST）。二叉排序树是一种特殊的二叉树，它满足以下条件： 1. 若左子树不为空，则左子树上所有节点的...
二叉排序树实现教师成果管理系统源码
01-09
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值，且满足以下性质：对于任意节点，其左子树中所有节点的键值均小于该节点的键值；其右子树中所有...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 605
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
操作系统原子操作
zzt_is_me的博客
08-28 5823
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 3637
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于Java+Springboot+Vue+elememt宠物用品商城系统设计实现
央顺科技官方博客
08-31 881
随着信息技术的不断发展，我们现在已经步入了信息化的时代了，而信息时代的代表便是网络技术的日渐成熟，而现在网络已经和我们的生活紧密的联系起来了，我们不敢想象没有网络我们的生活会像怎么样，也许就像食物中没有调料现在的生活离开了网络会变得索然无味。通过网络我们可以足不出户的做许多事情，例如工作、娱乐、学习，交友和购物等等许多我们数之不尽的事情，而就是因为网络我们的生活变得多姿多彩，或许有时甚至帮我们省下不少的时间和给予了我们更多的机遇。宠物网上商城对我们来说就有这些意义。
优秀的开源项目
猪猪
08-28 547
目录热key多线程并行秒级百G级日志工具ES操作工具消息推送平台HTTP 客户端业务层的分布式限流组件企业级微服务解决方案hotkey: 京东App后台中间件，毫秒级探测热点数据，毫秒级推送至服务器集群内存，大幅降低热key对数据层查询压力asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各线程的执行顺序，带全链路执行结果回调。多线程编排一站式解决方案。来自于京东主App后台。asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各
spring-data-redis中RedisRepository仓储
OceanSky的专栏
08-27 451
Id@RedisHash注解的value属性和@Id注解指定键值的命名空间，组合成user:id；@RedisHash的属性timeToLive属性指定键值的超时时间。CrudRepository接口中默认定义实现了save、saveAll、findById、existsById、findAll、findAllById、count、deleteById、delete、deleteAllById、deleteAll等方法，基本满足了对redis操作的需求；如果有特殊需求可以自定义实现。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 602
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 482
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
JVM 内存参数
iOS逆向与安全
08-29 1551
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
Java并发编程 进程与线程
m0_56369671的博客
08-28 917
操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的。但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms 注：需要在多核 cpu 才能提高效率，单核仍然时是轮流执行。
SpringBoot SSM vue在线作业考试系统
yinjl123456的博客
08-30 354
使用技术: SpringBoot或SSM + Mybaits + Mysql + vue(前端)后台管理 登录注册 个人中心 教师信息管理 学生信息管理 学院信息管理 专业信息管理。班级信息管理 作业信息管理 作业提交管理 通知公告管理 试卷管理 试题管理。系统管理 管理员管理 考试管理。
Java 虚方法表（虚函数）
最新发布
一心向阳，光芒万丈
08-31 431
虚方法表是一个类的内部数据结构，用于支持方法的动态绑定（即运行时多态）。每个类在加载时会生成一个虚方法表，其中包含了类中所有虚方法的地址。方法地址的存储：虚方法表存储了类的所有方法（包括继承自父类的方法）的内存地址或指针。这些方法在虚方法表中的顺序与它们在类中声明的顺序一致。动态绑定：当方法调用发生时，JVM 会根据对象的实际类型（而不是声明类型）来查找并调用正确的方法实现。这种机制允许程序在运行时决定调用哪个方法，从而实现多态。被privatestaticfinal。
二叉排序树（BST）详解与性质
"BST二叉排序树讲义涵盖了二叉检索树的基本定义、性质以及在实际操作中的应用，包括结点的删除等概念。" 二叉排序树（Binary Search Tree，简称BST），又称为二叉查找树，是一种特殊的二叉树数据结构，它具有以下...
评论 75
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爪哇土著、JOElib

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

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

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

打赏作者

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

抵扣说明：

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

余额充值