数据结构：二叉查找树（BST）

最新推荐文章于 2024-08-16 21:27:26 发布
最新推荐文章于 2024-08-16 21:27:26 发布
阅读量307 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apache_z/article/details/100902149
版权

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

代码实现

  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）&平衡二叉树（AVL）
iva_brother的博客
10-11 677
本系列博客整理自网络，其中加入部分个人见解，如果你在看到这个系列的博客的时候有似曾相识的感觉，非常正常，主要是用于本人以后学习与复习，参考的原博客的地址我也会在博客前面或后面给出。 二叉查找树（BST） 二叉查找树定义：二叉查找树(Binary Search Tree)，又被称为二叉搜索树。设x为二叉查找树中的一个结点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子...
数据结构 ： 二叉搜索树(BST)
LOOKTOMMER的博客
10-07 1334
????‍???? ????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍??????
【数据结构】二叉查找树（BST）
m0_46628950的博客
09-08 7520
二叉查找树(Binary Search Tree，BST)，又叫做二叉排序树、二叉搜索树，是一种对查找和排序都有用的特殊二叉树。二叉查找树的特性：左子树
二叉搜索树(Binary Search Tree)
最新发布
cookies_s_的博客
08-16 1368
二叉搜索树实现
二叉查找树（BST）
m0_50710793的博客
11-01 431
二叉查找树的定义 二叉查找树：是一种特殊的二叉树，又叫排序二叉树，二叉排序树，二叉搜索树等等。 具体定义如下： 要么二叉查找树是一棵空树 要么二叉查找树由根结点、左子树、右子树组成，其中左子树和右子树都是二叉查找树，且左子树上所有结点的数据域均小于根结点的数据域，右子树上所有结点的数据域均大于根结点的数据域～ （左<根<右） 二叉查找树的基本操作（查找、插入、建树、删除） 搜索基本思路： 1. 如果当前根结点为root，那么查找失败，返回～ 2. 如果要查找的值等于当前根结点的数据域，说明查
二叉搜索树（BST）
weixin_45629738的博客
04-06 167
定义结点 #include<iostream> #include<vector> #include<stack> using namespace std; typedef int KeyType; typedef struct BstNode { KeyType key; BstNode* leftchild; BstNode* parent; BstNode* rightchild; }BstNode, * BSTree;
树：二叉搜索树 （BST）
新华编程特战队
01-21 953
但是，如果随机插入元素，创建平衡树，则每个操作的平均时间复杂度为 O(log2N)，其中 N 是树中元素的数量。二叉搜索树 (BST) 对于动态数据集很有好处，因为它们提供高效的搜索、插入和删除操作，平均时间复杂度为 O(log2N)。今天我们讨论了一个非常棒的算法，它可以让二分搜索相形见绌 😛 如果数据集是随机和动态的，它为插入和搜索提供对数复杂度。因此，所有小于或等于当前节点的元素将出现在左子树中，所有严格大于当前节点的元素将出现在右子树中。是最常用的树版本，其中树的每个节点最多可以有两个子节点。
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：1.若它的左子树非空，则左子树上所有结点的值均小于根结点的值；2.若它的右...
JS算法与数据结构：二叉查找树（BST）深度解析
二叉查找树是数据结构中的重要组成部分，尤其在需要快速查找、插入和删除操作的场景中，如数据库索引和文件系统中。理解和熟练掌握二叉查找树的概念及其操作，对于提升JavaScript编程能力及解决实际问题大有裨益。
数据机构实验报告：二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造实验报告.doc
12-18
二叉排序树（BST），也称为二叉查找树，是一种特殊的二叉树，其每个节点的左子树中的所有节点值都小于该节点，而右子树中的所有节点值都大于该节点。这种特性使得BST非常适合于查找、插入和删除操作。在插入新节点时...
数据结构案例：二叉搜索树（Binary Search Tree, BST）.docx
07-17
二叉搜索树(Binary Search Tree, BST)是一种非常重要的数据结构，其核心特性在于能够快速地进行查找、插入以及删除操作。在二叉搜索树中，每个节点包含一个键值（通常是一个整数或者浮点数），并且满足以下条件： 1...
[算法]二叉搜索树（BST）
SUICIDEKILL的博客
08-05 1010
二叉搜索树 （BST） 是一种特殊类型的二叉树，其中每个顶点最多可以有两个子项。此结构遵循BST 属性，规定给定顶点的左侧子树中的每个结点的值必须小于给定顶点的值，并且右侧子树中的每个结点的值必须大于给定顶点的值。
BST（二叉搜索树）
毕业才是起点
04-28 6284
BST（二叉搜索树） 所谓二叉搜索树（Binary Search Tree，简称 BST）大家应该都不陌生，它是一种特殊的二叉树。 特殊在哪里呢？ 简单来说就是：左小右大。 BST的完整定义如下： BST 中任意一个节点的左子树所有节点的值都小于该节点的值，右子树所有节点的值都大于该节点的值。 BST 中任意一个节点的左右子树都是 BST。 有了BST的这种特性，就可以在二叉树中做类似二分搜索的操作，搜索一个元素的效率很高。 一个合法二叉树的举例 对于 BST 相关的问题，你可能会经常看到类似下面
数据结构之二叉搜索树（BST）
weixin_39765162的博客
07-16 445
二叉搜索树的基本原理和实现
【数据结构】-二叉搜索树(BST)
knoci的博客
04-23 1164
如图所示，二叉搜索树（binary search tree）满足以下条件。对于根节点，左子树中所有节点的值 < 根节点的值 < 右子树中所有节点的值。任意节点的左、右子树也是二叉搜索树，即同样满足条件1.。二分搜索树有着高效的插入、删除、查询操作。平均时间的时间复杂度为 O(log n)，最差情况为 O(n)。二分搜索树与堆不同，不一定是完全二叉树，底层不容易直接用数组表示故采用链表来实现二分搜索树。只有在高频添加、低频查找删除数据的场景下，数组比二叉搜索树的效率更高。查找元素插入元素。
二叉搜索树（BST-Tree）(C++全)
weixin_48560325的博客
04-28 5277
目录 二叉搜索树基本概念 1，什么是根节点 2、什么是二叉搜索树 3、二叉搜索树结构 4、二叉搜索树的性质 5、复杂度 算法实现 1、创建一个二叉搜索树节点 2、打印二叉搜索树 3、二叉搜索树的插入 4、其他操作 （1）查找二叉搜索树的最大值 （2）查找二叉搜索树的最小值 （3）查找某一节点的前驱 （4）查找某一节点的后继 5、删除二叉搜索树的某一节点 步骤： 代码： 性能分析 二叉搜索树基本概念 1，什么是根节点 根结点（root）是树的一个组成部分，也
二叉树(四) 二叉查找树(BST)
Oeljeklaus的博客
04-27 1673
二叉查找树：对于二叉查找树的任何一个节点，设这个节点的值为K，这个节点的左子树的任意一个节点的值都小于K，右子树的任何一个节点的值都大于等于K。对于任何的二叉查找树，使用中序遍历（左根右）,可以将值从小到大打印出来。对于二叉查找树的检索，例如图a，需要检索32，那么首先需要检索根节点，发现37大于32，进入二叉搜索树的左子树，发现24小于32，然后在进入右子树，发现根节点等于32，那么就返回找到了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

贝多芬也爱敲代码

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

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

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

打赏作者

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

抵扣说明：

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

余额充值