数据结构:二叉查找树(BST)

(一)BST树(二叉搜索树) (一)BST树(二叉搜索树) 1.BST二叉搜索树 1.1BST树的定义 1 BST树也是一个二叉树,故满足递归定义; 2 其次每个节点只存在一个值; 3 需满足左子树值<=根值<=右子树,故按照中序遍历会得到一个非递减序列。 BST涉及操作主要增,删,查,除了删麻烦一点,其他操作均可递归实现,二叉查找树的一般性质: 1.在一棵二叉查找树上,执行查找、插入、删除等操作,的时间复杂度为O(log2n)。因为,一棵由n个结点,随机构造的二叉查找树的高度为log2n,所以顺理成章,一般操作的执行时间为 阅读详情

定义:又叫二叉搜索树,它是一种特殊的二叉树,如果它的任意节点的左右节点存在,则它的左子树均小于这个节点,右节点均大于这个节点二叉搜索树

代码实现

  1. 定义这个树的属性
public class BSTree<T extends Comparable<T>> {

   private BSTNode<T> mRoot;    // 根结点

   public class BSTNode<T extends Comparable<T>> {
       T key;                // 关键字(键值)
       BSTNode<T> left;      // 左孩子
       BSTNode<T> right;     // 右孩子
       BSTNode<T> parent;    // 父结点

       public BSTNode(T key, BSTNode<T> parent, BSTNode<T> left, BSTNode<T> right) {
           this.key = key;
           this.parent = parent;
           this.left = left;
           this.right = right;
       }
   }

       ......
}
  1. 每一个二叉搜索树都是依靠头结点来为线索来连接整棵树 的

  2. 主要方法思路:
    查找:传入头结点,和要查找的值,递归如果比当前节点的值小,则要查找的节点应该在该节点的左子树,如果不存在左子树,这该值不在这个二叉树上,返回null,如果比当前节点大,则这个值应该在右子树上,相等则返回这个节点。
    查找最大小值:最大值就是这颗树的最右边的节点,就是不断的进入当前节点的右子树,直到当前节点没有右子树,则这个节点就是最大值。最小值则不断进入左子树,直到没有左子树。
    前驱:前驱表示的是当前二叉树按照中序排列,当前节点的前一个节点,也就是说,当前节点的左子树中最大的那个数(这个数没有右子树节点,因为没有比这个节点更大的)
    代码实现:先判断是否有左子树,有的话,就查找它左子树中最大的值,这个值就是前驱节点。没有的话,判断这个节点有没有父节点,没有的话,当前节点就是根节点,所以他的前驱节点应为为null,如果点前节点是右子树节点,则他的父节点就是他的前驱节点。如果他是左子树节点,那么应该找他的父节点中,这个节点不在是他的父节点的左子树,找到了就返回这个节点的父节点,找不到返回null
    后继:跟前驱相反。
    插入:就是先查找合适的插入节点,就是不断的跟当前节点比较,如果比当前节点大,就看是否存有右子树,存在就继续比较,直到没有,就在当前位置插入。比当前位置小的话,就查左子树,不存在就插入
    删除:就是先获取要删除的节点,查看这个节点是否存在左右父节点,所以分三种情况(1)不存在左右节点,直接设置它的父节点的做或者右节点为null(2)存在左或者右节点中的一个,先拿到这个节点,设置这个节点的父节点为当前节点的父节点,设置当前节点的父节点的左或者右节点为这个节点。(3)存在两个子节点,所以查找当前节点的后继节点(中序遍历第一个值),先记录该节点,然后在这个位置删除这个节点(这节点一定没有左子节点,或者没有子节点,所以这个节点删除就变成情况一二),并将要最初要删除节点的值设置为记录节点的值。

  3. 具体代码实现:

/**
* Java 语言: 二叉查找树
*
* @author skywang
* @date 2013/11/07
*/

public class BSTree<T extends Comparable<T>> {

   private BSTNode<T> mRoot;    // 根结点

   public class BSTNode<T extends Comparable<T>> {
       T key;                // 关键字(键值)
       BSTNode<T> left;    // 左孩子
       BSTNode<T> right;    // 右孩子
       BSTNode<T> parent;    // 父结点

       public BSTNode(T key, BSTNode<T> parent, BSTNode<T> left, BSTNode<T> right) {
           this.key = key;
           this.parent = parent;
           this.left = left;
           this.right = right;
       }

       public T getKey() {
           return key;
       }

       public String toString() {
           return "key:"+key;
       }
   }

   public BSTree() {
       mRoot=null;
   }

   /*
    * 前序遍历"二叉树"
    */
   private void preOrder(BSTNode<T> tree) {
       if(tree != null) {
           System.out.print(tree.key+" ");
           preOrder(tree.left);
           preOrder(tree.right);
       }
   }

   public void preOrder() {
       preOrder(mRoot);
   }

   /*
    * 中序遍历"二叉树"
    */
   private void inOrder(BSTNode<T> tree) {
       if(tree != null) {
           inOrder(tree.left);
           System.out.print(tree.key+" ");
           inOrder(tree.right);
       }
   }

   public void inOrder() {
       inOrder(mRoot);
   }


   /*
    * 后序遍历"二叉树"
    */
   private void postOrder(BSTNode<T> tree) {
       if(tree != null)
       {
           postOrder(tree.left);
           postOrder(tree.right);
           System.out.print(tree.key+" ");
       }
   }

   public void postOrder() {
       postOrder(mRoot);
   }


   /*
    * (递归实现)查找"二叉树x"中键值为key的节点
    */
   private BSTNode<T> search(BSTNode<T> x, T key) {
       if (x==null)
           return x;

       int cmp = key.compareTo(x.key);
       if (cmp < 0)
           return search(x.left, key);
       else if (cmp > 0)
           return search(x.right, key);
       else
           return x;
   }

   public BSTNode<T> search(T key) {
       return search(mRoot, key);
   }

   /*
    * (非递归实现)查找"二叉树x"中键值为key的节点
    */
   private BSTNode<T> iterativeSearch(BSTNode<T> x, T key) {
       while (x!=null) {
           int cmp = key.compareTo(x.key);

           if (cmp < 0) 
               x = x.left;
           else if (cmp > 0) 
               x = x.right;
           else
               return x;
       }

       return x;
   }

   public BSTNode<T> iterativeSearch(T key) {
       return iterativeSearch(mRoot, key);
   }

   /* 
    * 查找最小结点:返回tree为根结点的二叉树的最小结点。
    */
   private BSTNode<T> minimum(BSTNode<T> tree) {
       if (tree == null)
           return null;

       while(tree.left != null)
           tree = tree.left;
       return tree;
   }

   public T minimum() {
       BSTNode<T> p = minimum(mRoot);
       if (p != null)
           return p.key;

       return null;
   }
    
   /* 
    * 查找最大结点:返回tree为根结点的二叉树的最大结点。
    */
   private BSTNode<T> maximum(BSTNode<T> tree) {
       if (tree == null)
           return null;

       while(tree.right != null)
           tree = tree.right;
       return tree;
   }

   public T maximum() {
       BSTNode<T> p = maximum(mRoot);
       if (p != null)
           return p.key;

       return null;
   }

   /* 
    * 找结点(x)的后继结点。即,查找"二叉树中数据值大于该结点"的"最小结点"。
    */
   public BSTNode<T> successor(BSTNode<T> x) {
       // 如果x存在右孩子,则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
       if (x.right != null)
           return minimum(x.right);

       // 如果x没有右孩子。则x有以下两种可能:
       // (01) x是"一个左孩子",则"x的后继结点"为 "它的父结点"。
       // (02) x是"一个右孩子",则查找"x的最低的父结点,并且该父结点要具有左孩子",找到的这个"最低的父结点"就是"x的后继结点"。
       BSTNode<T> y = x.parent;
       while ((y!=null) && (x==y.right)) {
           x = y;
           y = y.parent;
       }

       return y;
   }
    
   /* 
    * 找结点(x)的前驱结点。即,查找"二叉树中数据值小于该结点"的"最大结点"。
    */
   public BSTNode<T> predecessor(BSTNode<T> x) {
       // 如果x存在左孩子,则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。
       if (x.left != null)
           return maximum(x.left);

       // 如果x没有左孩子。则x有以下两种可能:
       // (01) x是"一个右孩子",则"x的前驱结点"为 "它的父结点"。
       // (01) x是"一个左孩子",则查找"x的最低的父结点,并且该父结点要具有右孩子",找到的这个"最低的父结点"就是"x的前驱结点"。
       BSTNode<T> y = x.parent;
       while ((y!=null) && (x==y.left)) {
           x = y;
           y = y.parent;
       }

       return y;
   }

   /* 
    * 将结点插入到二叉树中
    *
    * 参数说明:
    *     tree 二叉树的
    *     z 插入的结点
    */
   private void insert(BSTree<T> bst, BSTNode<T> z) {
       int cmp;
       BSTNode<T> y = null;
       BSTNode<T> x = bst.mRoot;

       // 查找z的插入位置
       while (x != null) {
           y = x;
           cmp = z.key.compareTo(x.key);
           if (cmp < 0)
               x = x.left;
           else
               x = x.right;
       }

       z.parent = y;
       if (y==null)
           bst.mRoot = z;
       else {
           cmp = z.key.compareTo(y.key);
           if (cmp < 0)
               y.left = z;
           else
               y.right = z;
       }
   }

   /* 
    * 新建结点(key),并将其插入到二叉树中
    *
    * 参数说明:
    *     tree 二叉树的根结点
    *     key 插入结点的键值
    */
   public void insert(T key) {
       BSTNode<T> z=new BSTNode<T>(key,null,null,null);

       // 如果新建结点失败,则返回。
       if (z != null)
           insert(this, z);
   }

   /* 
    * 删除结点(z),并返回被删除的结点
    *
    * 参数说明:
    *     bst 二叉树
    *     z 删除的结点
    */
   private BSTNode<T> remove(BSTree<T> bst, BSTNode<T> z) {
       BSTNode<T> x=null;
       BSTNode<T> y=null;

       if ((z.left == null) || (z.right == null) )
           y = z;
       else
           y = successor(z);

       if (y.left != null)
           x = y.left;
       else
           x = y.right;

       if (x != null)
           x.parent = y.parent;

       if (y.parent == null)
           bst.mRoot = x;
       else if (y == y.parent.left)
           y.parent.left = x;
       else
           y.parent.right = x;

       if (y != z) 
           z.key = y.key;

       return y;
   }

   /* 
    * 删除结点(z),并返回被删除的结点
    *
    * 参数说明:
    *     tree 二叉树的根结点
    *     z 删除的结点
    */
   public void remove(T key) {
       BSTNode<T> z, node; 

       if ((z = search(mRoot, key)) != null)
           if ( (node = remove(this, z)) != null)
               node = null;
   }

   /*
    * 销毁二叉树
    */
   private void destroy(BSTNode<T> tree) {
       if (tree==null)
           return ;

       if (tree.left != null)
           destroy(tree.left);
       if (tree.right != null)
           destroy(tree.right);

       tree=null;
   }

   public void clear() {
       destroy(mRoot);
       mRoot = null;
   }

   /*
    * 打印"二叉查找树"
    *
    * key        -- 节点的键值 
    * direction  --  0,表示该节点是根节点;
    *               -1,表示该节点是它的父结点的左孩子;
    *                1,表示该节点是它的父结点的右孩子。
    */
   private void print(BSTNode<T> tree, T key, int direction) {

       if(tree != null) {

           if(direction==0)    // tree是根节点
               System.out.printf("%2d is root\n", tree.key);
           else                // tree是分支节点
               System.out.printf("%2d is %2d's %6s child\n", tree.key, key, direction==1?"right" : "left");

           print(tree.left, tree.key, -1);
           print(tree.right,tree.key,  1);
       }
   }

   public void print() {
       if (mRoot != null)
           print(mRoot, mRoot.key, 0);
   }
}
数据结构:二叉查找树 BST 平均查找长度 ASL 的计算 平均查找长度 ASL(Average Search Length),即平均查找长度,在查找运算中,由于所费时间在关键字的比较上,所以把平均需要和待查找值比较的关键字次数称为平均查找长度。 它的定义是这样的: 其中n为查找表中元素个数,Pi为查找第i个元素的概率,通常假设每个元素查找概率相同,Pi=1/n,Ci是找到第i个元素的比较次数。 顺序查找平均查找长度的计算 在顺序查找(Sequence Search)表中,查找方式为从头扫到尾,找到待查找元素即查找成功,若到尾部没有找到,说明查找失败。 所以说,Ci 阅读详情

相关推荐

Android TV开发:RecyclerView焦点控制实践与优化

在Android TV应用开发中,焦点控制是提升用户体验的关键技术。不同于移动端触摸交互,TV端通过遥控器方向键导航,需要精确的焦点管理机制。RecyclerView作为动态列表的核心组件,其焦点控制涉及视图复用、导航逻辑和视觉反馈等核心技术点。通过合理配置focusable属性、自定义焦点查找算法以及优化动画性能,开发者可以解决TV端常见的焦点跳转异常、视觉反馈延迟等问题。特别是在视频点播、智能家居控制等场景中,良好的焦点控制能显著提升操作效率。本文结合网格布局焦点环绕、分页加载焦点保持等实战案例,深入解

weixin_34195142的博客 469

二叉排序树(BST)的存储结构及基本操作

1.存储结构定义 typedef struct BSTNode{ ElemType data; Struct *lchild,*rchild; }BSTNode,*BSTree; 2.查找 BSTNode *BST_Search(BSTree T,ElemType key) { while(T!=NULL&&key!=T->data) { if(key<T->data) T=T->lchild; else T=T->rchi

vener_的博客 2120

FastApi教程

HTTP协议是Hyper Text Transfer Protocol(超文本传输协议)的缩写,是用于万维网(WWW:World Wide Web )服务器与本地浏览器之间传输超文本的传送协议。HTTP是一个属于应用层的面向对象的协议,由于其简捷、快速的方式,适用于分布式超媒体信息系统。它于1990年提出,经过几年的使用与发展,得到不断地完善和扩展。HTTP协议工作于客户端-服务端架构为上。浏览器作为HTTP客户端通过URL向HTTP服务端即WEB服务器发送所有请求。

小石潭记丶 1565

【数据结构基础】树 - 二叉搜索树(BST)

本文主要介绍 二叉树中最基本的二叉查找树(Binary Search Tree),(又:二叉搜索树,二叉排序树)它或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值; 若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值; 它的左、右子树也分别为二叉排序树。

DeveloperFire的博客 1381

数字IC后端设计实现 | PR工具中到底应该如何控制density和congestion?(ICC2&Innovus)

数字IC后端设计实现中到底应该如何控制cell density和congestion?(ICC2和Innovus两种解决方案)

weixin_37584728的博客 7113

《AFSim 2.9中文参考手册》

本栏目将对《AFSim 2.9中文参考手册》进行持续更新,欢迎关注交流!对本文或者AFSIM相关内容感兴趣的朋友,可私心联系作者。《AFSim 2.9中文参考手册》内容概览。

henggesim的博客 1万+

算法 二叉树 BST树

二叉排序树BST树的定义BST树结构BST树的创建递归中序遍历非递归中序遍历逆向非递归中序遍历删除结点 BST树的定义 BST树又称为:二叉排序树,二叉搜索树 二叉搜索树或者是一颗空树,或者是具有下列性质的二叉树 每个结点都有一个作为搜索依据的关键码(key),所有结点的关键码互不相同 左子树(如果存在)上所有结点的关键码都小于根节点的关键码 右子树(如果存在)上所有结点的关键码都大于根节点的关键码 左子树和右子树也是二叉搜索树 总结:如果对一颗二叉搜索树进行中序遍历,可以按从小到大的顺序,将各结

XXXTENTAC1ON的博客 2442

AMBA-CHI协议详解(二)

读事务,写事务,原子事务,Stash事务,Dataless事务,DVM事务,Retry事务。

Crazzy_M的博客 6660

【C++】二叉搜索树(BST)

一.基本介绍 特征: 二叉搜索树,也被称为二叉查找树、有序二叉树或者排序二叉树。 ∙\bullet∙ 一般来说输入的第一个数作为根结点,当继续输入数时,小于根结点的放在根结点左边,大于根结点的放在根结点右边。 ∙\bullet∙ 不只是根结点,每个子节点也符合左小右大的规律。 ∙\bullet∙ 如下图所示,输入数据8、3、10、1、6、14、4、7、13,得到下面的二叉搜索树。 下面我们来介绍BST的构成成分: ∙\bullet∙ 首先我们需要实现两个类:一个是BSTNode类(节点类)、一个为

taoxing 1116

数仓建模—数据语义层

如今,企业产生大量数据,需要以正确的方式进行分析才能做出重要决策。数据可能来自多个来源并采用不同的格式,这使得清楚地了解其含义和重要性成为一项挑战。这就是语义层的用武之地。语义层存在于数据仓库和最终用户使用的应用程序之间。它为用户提供了简化且一致的数据视图,无论其基础数据源的复杂性如何。该逻辑层有助于映射物理数据结构以创建概念数据模型。它定义了数据元素之间的所有规则和关系,并以业务术语提供了数据的通用词汇表。然后,用户可以轻松地与数据进行交互,而无需了解其数据源的技术知识。

7万+

代码接单:用 ComfyUI 搭建电商模特换装工作流(保姆级教程)

在闲鱼和小红书上,搜一下“AI 模特图”或者“服装换模特”,你会发现大量的接单需求。太贵:请个外模拍一套图,动辄几千块。太慢:寄样品、排期、拍摄、修图,半个月过去了。太卷:竞对都在上新,你还在等图。“给我一张你的衣服平铺图(或假人图),我 10 分钟给你生成真人上身图,一张只要 50 块。对于商家是省钱,对于你是纯利润。为什么不用 Midjourney?因为 MJ 抽卡不可控,无法保持衣服版型一致。只有 ComfyUI,才能做到精准控制,实现工业化量产。

BUG猿的博客 1786

数据结构: 二叉查找树(BST)

二叉查找树是一种很有意思的数据结构, 比根节点小的元素将被存储在左子树中,比根节点大的元素被存储在右子树中。这就保证了中序遍历该二叉查找树时必然是升序排序的。平均情况下: 二分查找的时间复杂度为O(logN) 二叉查找树 查找操作 花费的时间是二分查找的1.39倍但这些开销是值得的,因为二分查找的存储依靠有序数组。有序数组 插入操作 的时间复杂度为O(N),而二叉查找树的 插入操

earayu的博客 602

【项目实战】SOVD协议(面向服务的车辆诊断协议)

此外,AUTOSAR组织将SOVD部分内容的软件实现定义在了R22-11及以上版本的AUTOSAR Adaptive规范中,还支持动态发现车内诊断功能、获取高性能计算机(HPC)的Log信息等新的诊断需求,更符合当前软件定义汽车概念下的行业趋势。而SOVDGateway作为边缘节点,也肩负着对SOVD Client进行认证以及权限控制的责任,从而保证车辆的信息安全。相较于传统的UDS(Unified Diagnostic Services)协议,SOVD不仅保留了传统的读写数据、例程控制、故障读取等功能,

奶爸的编程之路,也就一周冷个三天 1905

高级数据结构及算法:BST树(二叉查找树)

文章目录二叉查找树1. 特点2. 操作2.1 查找2.2 添加2.3 删除 二叉查找树 二叉查找树(Binary Search Tree),又被称为二叉搜索树 二叉查找树演示连接 1. 特点 任意节点的左子树不空, 则左子树上所有节点的key均小于它的根节点的key 任意节点的右子树不空, 则右子树上所有节点的key均大于它的根节点的key 任意节点的左,右子树也分别为二叉查找树 没有key相等的节点 2. 操作 2.1 查找 2.2 添加 2.3 删除 ...

凯凯在此 364

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

数据结构:二叉查找树(BST)&平衡二叉树(AVL)

本系列博客整理自网络,其中加入部分个人见解,如果你在看到这个系列的博客的时候有似曾相识的感觉,非常正常,主要是用于本人以后学习与复习,参考的原博客的地址我也会在博客前面或后面给出。 二叉查找树(BST) 二叉查找树定义:二叉查找树(Binary Search Tree),又被称为二叉搜索树。设x为二叉查找树中的一个结点,x节点包含关键字key,节点x的key值记为key[x]。如果y是x的左子...

iva_brother的博客 818

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

《数据结构与算法》实验:查找结构的实验比较——二叉查找树BST & 二分(折半)查找

《数据结构与算法》实验和课程Github资源 《数据结构与算法》实验:线性结构及其应用——算术表达式求值 《数据结构与算法》实验:树型结构的建立与遍历 《数据结构与算法》实验:图结构的建立与搜索 《数据结构与算法》实验:查找结构的实验比较——二叉查找树BST & 二分(折半)查找 《数据结构与算法》实验:排序算法实验比较——选择排序 & 堆排序 《数据结...

Zhuoning Guo's Blog 4786

[重修数据结构0x04]特殊二叉树:二叉查找树(BST)、平衡二叉树(AVL树)、哈夫曼树

前言 看了Acwing老师的一些课

qq_42523037的博客 186

数据结构学习-BST二叉查找树 : 插入、删除、中序遍历、前序遍历、后序遍历、广度遍历、绘图...

二叉查找树(Binary Search Tree) 是一种树形的存储数据的结构 如图所示,它具有的特点是: 1、具有一个根节点 2、每个节点可能有0、1、2个分支 3、对于某个节点,他的左分支小于自身,自身小于右分支 接下来我们用c++来实现BST的封装 首先我们编写每个节点的类结构,分析可以知道我们每一个节点需要存储一个数据(data),左分支(left指向一个节点),右分支(...

weixin_30713953的博客 148

数据结构:(代码篇:004)二叉搜索树 BST(二叉查找树)的基本操作

1.基本概念 二叉搜索树:是二叉树是真子集,要求:根节点大于或等于左子树的节点值,小于右子树的节点值。 他的中序遍历是有序的。 基本操作有:查找、插入、删除、建树。 查找和插入以及建树都很简单,和二叉树的差不多。删除略微复杂。 2.存储结构 struct node{ int data; node* lchild; node* rchild; }; ...

小渣渣的博客 352

Python数据结构11:树的实现,树的应用,前中后序遍历,二叉查找树BST,平衡二叉树AVL树,哈夫曼树和哈夫曼编码

树的概念和相关算法

YangStudent的博客 2303

数据结构与算法(java):树-二叉树(二叉查找树(BST)、线索化二叉树、哈夫曼树、平衡二叉树【AVL】、二叉树的前中后序遍历)

树 1、概述

lalala_dxf的博客 627

二叉查找树的查找

二叉查找树

实践求真知 901

二叉查找树(BST)删除操作全解析:从理论到代码实现的深度拆解

本文深度解析二叉查找树(BST)删除操作的实现逻辑与代码实践,涵盖叶子节点、单子节点和双子节点三种场景的处理方法。通过Python和C++双语示例演示如何保持中序遍历序列的连续性,并提供调试技巧与性能优化建议,帮助开发者掌握BST删除操作的核心原理与工程实践。

weixin_33178839的博客 248

《算法笔记》9.4小节——数据结构专题(2)->二叉查找树(BST)->问题 A: 二叉排序树

问题 A: 二叉排序树 时间限制:1 Sec内存限制:32 MB 提交:519解决:225 [提交][状态][讨论版][命题人:外部导入] 题目描述 输入一系列整数,建立二叉排序数,并进行前序,中序,后序遍历。 输入 输入第一行包括一个整数n(1<=n<=100)。接下来的一行包括n个整数。 输出 可能有多组测试数据,对于每组数据,将题目所给数据建立一个二...

最不正经的计算机专业学生 334

统计输入中所有单词出现的次数(使用二叉查找树实现:递归和非递归)

/*@function:统计输入中的所有单词出现的次数 * @method: 使用二叉查找树。对输入的单词建立一颗二叉查找树,新输入的单词若存在于树中,则增加该节点的计数值;否则,新增一个节点 */ #include #include #include #include #define MAXWORD 100 typedef struct tnode { char word[MAXW

Brave master的专栏 1468

什么是二叉树,红黑树?二叉树、红黑树的基本特征?红黑树的实际应用场景?真正读懂红黑树的数据结构

1.什么是二叉查找树 A.二叉查找树(BST)具备什么特性呢? (1)左子树上的所有结点的值均小于或等于他的根结点的值 (2) 右子树上的所有结点的值均大于或等于他的根结点的值 (3)左、右子树也分别为二叉排序树 文章太难写了,大家直接看下面这个链接地址吧,动画的形式展现更具体一些: https://juejin.cn/post/6844903519632228365 ...

mischen520的博客 158
上一篇: 数据结构:String
下一篇: 数据结构:红黑树
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

贝多芬也爱敲代码

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

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

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

打赏作者

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

抵扣说明:

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

余额充值