devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构-二叉排序树（BST树）

作者：Gausst松鼠会 | 2024-04-28 14:12:41

赞

踩

数据结构-二叉排序树（BST树）

 

目录

1，二叉排序树介绍

1.1，二叉排序树的构建和插入

1.2，二叉排序树的查找过程

1.3，二叉排序树的性能分析

2，二叉排序树的实现

2.1，二叉排序树的节点类型

2.2，二叉排序树的查找操作

2.3，递归构建二叉排序树

2.4，中序遍历二叉树

2.5，二叉排序树的删除操作

2.5.1，查找待删除的节点

2.5.2，查找待删除节点的父节点

2.6.查找最大值和最小值

2.7，创建一颗二叉排序树

2.8，测试代码

2.9，二叉排序树小结

1，二叉排序树介绍

二叉排序树（Binary Sort Tree）或者是一颗空树；或者是具有如下性质的二叉树：

  • 若它的左子树不空，则 左子树 上所有结点的值 均小于 它的根结点的值；
  • 若它的右子树不空，则 右子树 上所有结点的值 均大于 它的根结点的值；
  • 它的 左、右子树又分别为二叉排序树 。

显然二叉排序树的定义是一个递归形式的定义，所以后面景禹要讲的插入、查找和删除都是基于递归的形式。特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点

1.1，二叉排序树的构建和插入

  • 假设我们有初始的无序序列：

  • 第一步：插入7作为我们二叉排序树的根节点。

  • 第二步：插入节点3,3和7进行比较，发现3小于根节点7，那么就把3这个节点作为7的左子树。

  • 第三步：插入节点10，发现节点10比根节点的值7大，于是就把10这个节点作为根节点的左子节点插入其右边。

  • 第四步：插入节点12，发现12比根节点7大，于是就再和节点7的右子节点比较，但是10小于节点12，所以就把节点12作为10这个节点的右孩子节点。

  • 第五步：插入节点5，5小于根节点7，于是就把5和根节点的左孩子3比较，5大于3，所以节点5作为节点3的右孩子节点。

  • 第六步：插入节点1,1和7比较，小于7，然后再和3比较，小于3，于是就作为节点3的左孩子。

  • 第七步：插入节点9,9大于根节点7，但是小于节点10，于是就把9作为节点10的左孩子。

经过多次的插入节点，最终我们建立的二叉排序树如上图所示。我们对建立好的二叉排序树做中序遍历操作，发现遍历结果是一个有序的序列，这也是二叉排序树的特点：中序遍历有序。

1.2，二叉排序树的查找过程

二叉查找树的查找是从根节点开始的，延某一个分支逐渐向下比较的过程，如果二叉树非空，那么就把给定的值先和根节点进行比较，如果相等，那么就查找成功，如果小于根节点，那么就在根节点的左子树上面进行递归查找，如果大于根节点的值，就在根节点的右子树上面进行递归查找。

1.3，二叉排序树的性能分析

二叉排序树的查找性能主要取决于树的高度，如果二叉排序树的左右子树的高度差不超过1，那么这样的树称为平衡二叉树，后面会介绍，这样的平衡二叉树的平均查找长度是O(Log2n),但是如果二叉排序树构建的是一棵单支树，那么查找效率最差，和线性查找几乎差不多，为O(N),所以我们在构建二叉排序树的时候力求构建的二叉排序树尽可能的低，最好的二叉排序树是二分查找生成的二叉判定树。当然，对于二叉排序树可能生成单支树的情况，后面我们还有更好的解决办法----AVL树。

2，二叉排序树的实现

2.1，二叉排序树的节点类型

  1. //二叉排序树的节点类型
  2. class BSTNode{
  3.     private int data;
  4.      BSTNode left;
  5.      BSTNode right;
  6. public BSTNode(int data) {
  7.         this.data = data;
  8.     }
  9.  
  10.     public int getData() {
  11.         return data;
  12.     }
  13.  
  14.     public BSTNode getLeft() {
  15.         return left;
  16.     }
  17.  
  18.     public BSTNode getRight() {
  19.         return right;
  20.     }
  21.  
  22.     public void setData(int data) {
  23.         this.data = data;
  24.     }
  25.  
  26.     public void setLeft(BSTNode left) {
  27.         this.left = left;
  28.     }
  29.  
  30.     public void setRight(BSTNode right) {
  31.         this.right = right;
  32.     }
  33.  
  34.     @Override
  35.     public String toString() {
  36.         return "BSTNode{" +
  37.                 "data=" + data +
  38.                 '}';
  39.     }
  40.  
  41. }

2.2，二叉排序树的查找操作

二分查找是在一个有序数组上进行的，就像前面我们通过对二叉排序树进行中序遍历得到的结果一样，初始时，我们将整个有序数组当做二分查找的搜索空间，然后计算搜索空间的中间元素，并与查找元素进行比较；然后将整个搜索空间缩减一半；重复上面的步骤，直到找到待查找元素或者返回查找失败的信息。二叉排序树的查找操作和二分查找类似，每一次都和子树的根节点进行比较，直到查找到为止。

  1.  /**
  2.      * 二叉排序树中查找一个元素，根据节点的值进行查找
  3.      * @param value 待查找节点的值
  4.      * @return 查找到就返回该节点，否则返回null
  5.      */
  6.      public BSTNode searchValue(int value){
  7.          if(this.getData() == value){
  8.              return this;
  9.          }else if(value <this.getData()){
  10.              if(this.left == null){
  11.                  return null;
  12.              }
  13.              return this.left.searchValue(value);
  14.          }else if(value >this.getData()){
  15.              if(this.right == null){
  16.                  return null;
  17.              }
  18.              return this.right.searchValue(value);
  19.          }
  20.          return null;
  21.      }

2.3，递归构建二叉排序树

从上面二叉排序树的查找过程可以看出，查找是一个递归的过程，而建立二叉排序树也是一个递归的过程。对于任意一个待插入的元素 x 都是插入在二叉排序树的叶子结点，问题的关键就是确定插入的位置，原理当然和上面的查找操作一样，从根结点开始进行判断，直到到达叶子结点，则将待插入的元素作为一个叶子结点插入即可。

  1.  /**
  2.      * 向二叉排序树中添加一个节点
  3.      * @param node 需要添加的节点
  4.      */
  5.     public void add(BSTNode node){
  6. //        判断添加的节点是否是空
  7.         if(node == null){
  8.             return ;
  9.         }
  10. //        判断当前节点的值和根节点的值大小
  11.         if(node.getData() < this.getData()){
  12.             if(this.getLeft() == null){
  13. //                如果左子节点为空，直接挂上去即可
  14.                 this.left=node;
  15.             }else {
  16. //                如果不是空，就递归进行向左子树添加
  17.                 this.left.add(node);
  18.             }
  19.         }else {
  20. //            判断左子树是否是空，空的话直接添加节点
  21.             if(this.right == null){
  22.                 this.right=node;
  23.             }else {
  24. //                不空的话递归在左子树进行添加
  25.                 this.right.add(node);
  26.             }
  27.         }
  28.  
  29.     }

2.4，中序遍历二叉树

  1. //    中序遍历二叉树
  2.     public void midOrder(){
  3.         if(this == null){
  4.             return;
  5.         }
  6.         if(this.left != null){
  7.             this.left.midOrder();
  8.         }
  9.         System.out.println(this.getData());
  10.         if(this.right != null){
  11.             this.right.midOrder();
  12.         }
  13.     }

2.5，二叉排序树的删除操作

二叉排序树的删除一个节点稍稍麻烦，因为我们每删除一个节点的时候，需要保证删除后仍然符合二叉排序树的定义，二叉排序树的删除操作分为三种情况，下面我们来看具体是如何删除一个节点。

  • 假如我们删除的是一个叶子结点：如果删除的是二叉排序树的一个叶子节点，那我们查找到这个节点之后就可以直接删除，因为删除叶子结点不会影响我们二叉排序树的整体情况，仍然是一棵二叉排序树，符合二叉排序树的定义。对于上面建立好的二叉树，如果我们删除叶子结点12，那么二叉排序树删除后的形态如下：

  • 被删除的结点D仅有一个孩子：如果只有左孩子，没有右孩子，那么只需要把要删除结点的左孩子链接到要删除结点的父亲节点，然后删除D结点就好了；如果只有右孩子，没有左孩子，那么只要将要删除结点D的右孩子重接到要删除结点D的父亲结点。我们以删除节点10为例：

对于要删除的节点10，只有一个左子节点，那我们把节点10删除后，需要用他的左子节点来代补充他的位置。

  • 被删除结点的左右孩子都存在：对于这种情况，我们有两种处理方法。下面我们以删除节点3为例。
    • 第一步：我们先获取待删除节点右子树上的最小值，在这里也可以获取待删除节点左子树上的最小值。

  • 第二步：我们已经找到待删除节点右子树上的最小值，这一步我们使用这个最小值代替待删除节点里面的值，然后把这个最小值节点删除即可。

  •  补充：我们也可以找到待删除节点左子树上的最大值，做同样的处理即可。

2.5.1，查找待删除的节点

  1.  /**
  2.      * 查找要删除的节点
  3.      * @param value 要查找节点的值
  4.      * @return 如果找到该节点就返回，否则就返回null
  5.      */
  6.     public BSTNode search(int value){
  7.         if(this.getData() == value){
  8.             return this;
  9.         }else if(value < this.getData()){
  10.             if(this.left == null){
  11.                 return null;
  12.             }
  13. //            左子树递归查找
  14.            return this.left.search(value);
  15.         }else {
  16.             if(this.right == null){
  17.                 return null;
  18.             }
  19.             return this.right.search(value);
  20.         }
  21.     }

2.5.2，查找待删除节点的父节点

  1. /**
  2.      * 查找要删除节点的父节点
  3.      * @param value 要删除节点的值
  4.      * @return 查找到就返回
  5.      */
  6.     public BSTNode searchParent(int value){
  7.         if((this.left != null && this.left.getData()==value)||(this.right != null && this.right.getData()==value)){
  8.             return this;
  9.         }else {
  10. //            如果待查找的节点值小于当前的节点的值，并且当前节点的左子树不是空，就递归在左子树查找
  11.             if(  value < this.getData()&& this.left != null){
  12.                 return  this.left.searchParent(value);
  13.             }else if(value >=this.getData()&& this.right != null){
  14.                 return this.right.searchParent(value);
  15.             }else {
  16. //                没有找到父节点
  17.                 return null;
  18.             }
  19.         }
  20.     }

2.6.查找最大值和最小值

  1.  /**
  2.      * 查找二叉排序树中的最小值
  3.      * @return 返回最小值的节点
  4.      */
  5.     public  BSTNode searchMinBSTNode(){
  6.         BSTNode bstNode=this;
  7.         if(bstNode!= null){
  8.             while (bstNode.getLeft()!= null){
  9.                 bstNode=bstNode.getLeft();
  10.             }
  11.             return bstNode;
  12.         }else {
  13.             return null;
  14.         }
  15.     }
  16.  
  17.     /**
  18.      * 查找二叉排序树中的最大值
  19.      * @return
  20.      */
  21.     public  BSTNode searchMaxBSTNode(){
  22.         BSTNode bstNode=this;
  23.         if(bstNode!= null){
  24.             while (bstNode.getRight()!= null){
  25.                 bstNode=bstNode.getRight();
  26.             }
  27.             return bstNode;
  28.         }else {
  29.             return null;
  30.         }
  31.     }

2.7，创建一颗二叉排序树

  1. //创建一棵二叉排序树
  2. class BinarySortedTree{
  3.     private BSTNode root;
  4.  
  5.     /**
  6.      * 查找二叉排序树中的最小值节点
  7.      * @return 返回最大值的节点
  8.      */
  9.     public BSTNode searchMinBSTNode(){
  10.         if(this.root == null){
  11.             return null;
  12.         }else {
  13.             return this.root.searchMinBSTNode();
  14.         }
  15.  
  16.     }
  17.  
  18.     /**
  19.      * 查找二叉排序树中的最大值节点
  20.      * @return 返回最大值的节点
  21.      */
  22.     public BSTNode searchMaxBSTNode(){
  23.         if(this.root == null){
  24.             return null;
  25.         }else {
  26.             return this.root.searchMaxBSTNode();
  27.         }
  28.  
  29.     }
  30.      public BSTNode searchValue(int value){
  31.          if(this.root== null){
  32.              return null;
  33.          }else {
  34.              return this.root.searchValue(value);
  35.          }
  36.      }
  37.  
  38.     /**
  39.      * 向二叉排序树中添加一个节点
  40.      * @param node 待添加而定节点
  41.      */
  42.     public void add(BSTNode node){
  43.         if(this.root == null){
  44.             this.root=node;
  45.         }else {
  46.             this.root.add(node);
  47.         }
  48.     }
  49.  
  50.     /**
  51.      * 中序遍历二叉树
  52.      */
  53.     public void midOrder(){
  54.         if(this.root == null){
  55.             System.out.println("当前二叉排序树是空树！");
  56.             return;
  57.         }else {
  58.             this.root.midOrder();
  59.         }
  60.     }
  61.  
  62.     /**
  63.      * 查找延删除的节点
  64.      * @param value 待查找节点的值
  65.      * @return 发挥查找到的节点
  66.      */
  67.     public BSTNode Search(int value){
  68.         if(this.root == null)
  69.             return null;
  70.         else {
  71.             return this.root.search(value);
  72.         }
  73.     }
  74.  
  75.     /**
  76.      * 查找待删除节点的父节点
  77.      * @param value 待删除节点的值
  78.      * @return 返回查找到的值
  79.      */
  80.     public BSTNode searchParent(int value){
  81.         if(this.root ==null){
  82.             return null;
  83.         }else {
  84.             return this.root.searchParent(value);
  85.         }
  86.     }
  87.  
  88.     /**
  89.      * 删除二叉排序树中的一个节点
  90.      * @param value 待删除节点的值
  91.      */
  92.     public void deleteNode(int value){
  93.         if(this.root == null){
  94.             return;
  95.         }else {
  96. //            获取待删除的节点
  97.             BSTNode targetNode=Search(value);
  98.             if(targetNode == null){
  99. //                如果没有找到待删除的节点
  100.                 return;
  101.             }
  102. //            如果我们发现当前二叉树只有一个节点
  103.             if(root.getLeft() ==null&& root.getRight() == null){
  104.                 root=null;
  105.                 return;
  106.             }
  107. //            查找父节点
  108.             BSTNode parent=searchParent(value);
  109. //            判断待删除节点是否是叶子结点
  110.             if(targetNode.getLeft() == null && targetNode.getRight() == null){
  111.                 if(parent.getLeft() != null && parent.left.getData() == value){
  112. //                    说明当前节点是父节点的左子节点
  113.                     parent.left=null;
  114.                 }else if(parent.right != null && parent.right.getData() == value){
  115. //                    说明当前节点是父节点的右子节点
  116.                     parent.right=null;
  117.                 }
  118.             }else if(targetNode.getLeft() != null && targetNode.getRight() != null){
  119. //                也就是说待删除节点的左右子节点都不是空
  120. //                在右子树上面找到最小值节点删除
  121.                 int minRight=delRightNodeMin(targetNode.right);
  122.                 targetNode.setData(minRight);
  123. //                在这里也可以从左子树找最大值的节点
  124.             }else {
  125. //                删除只有一颗子树的节点
  126.                 if(parent !=null){
  127. //                    如果树只剩下根节点和左子节点，需要特殊判断，因为根节点没有父节点
  128.                     if(targetNode.left != null)
  129.                     {
  130. //                    也即是待删除节点的左子树不空
  131.                         if(parent.left.getData() ==value){
  132. //                        待删除节点是parent的左子节点
  133.                             parent.left=targetNode.left;
  134. //                        待删除节点是parent的左子节点并且待删除节点也有左子节点
  135.                         }else {
  136. //                        待删除节点是parent节点的右子节点
  137.                             parent.right=targetNode.left;
  138.                         }
  139.                     }else {
  140.                     if(parent!=null){
  141. //                        也就是要删除的节点有右子节点
  142.                         if(parent.left.getData() ==value){
  143.                             parent.left=targetNode.right;
  144.                         }else {
  145. //                        待删除节点是parent节点的右子节点
  146.                             parent.right=targetNode.right;
  147.                         }
  148.                     }else {
  149.                         root=targetNode.right;
  150.                     }
  151.                     }
  152.                 }else {
  153.                     root=targetNode.left;
  154.                 }
  155.  
  156.  
  157.             }
  158.         }
  159.  
  160.     }
  161.  
  162.     /**
  163.      * 返回以node为根节点的右子树上面的最小值节点，并且删除最小值节点
  164.      * @param node 作为子树的根节点
  165.      * @return 返回以node为根节点的右子树上最小值节点的值
  166.      */
  167.     public int  delRightNodeMin(BSTNode node){
  168.         BSTNode bstNode= node;
  169. //        循环找到左子树节点
  170.         while (bstNode.left != null){
  171.             bstNode=bstNode.left;
  172.         }
  173. //        退出循环，bstNode指向最小值的节点
  174.         deleteNode(bstNode.getData());
  175.         return bstNode.getData();
  176.     }
  177. }

2.8，测试代码

  1. public class BinarySortedTreeDemo {
  2.     public static void main(String[] args) {
  3.         int []arr={7,3,10,12,5,1,9,2};
  4. //        c创建一棵二叉排序树
  5.         BinarySortedTree binarySortedTree=new BinarySortedTree();
  6.         for(int i=0;i<arr.length;i++){
  7.             binarySortedTree.add(new BSTNode(arr[i]));
  8.         }
  9.         //binarySortedTree.deleteNode(7);
  10.        // binarySortedTree.midOrder();
  11. //        查找节点元素
  12. //        System.out.println(binarySortedTree.searchValue(9));
  13. //        查找最大值
  14.         BSTNode bstNode=binarySortedTree.searchMaxBSTNode();
  15. //        System.out.println(bstNode);
  16. //        查找最小值节点
  17.         BSTNode bstNode1=binarySortedTree.searchMinBSTNode();
  18.         System.out.println(bstNode1);
  19.     }
  20. }

2.9，二叉排序树小结

每个结点的Ci为该结点的层次数。最好的情况是二叉排序树的形态和折半查找的判定树相同，其平均查找长度和logn成正比（O(log2(n))）。最坏情况下，当先后插入的关键字有序时，构成的二叉排序树为一棵斜树，树的深度为n，其平均查找长度为(n + 1) / 2。也就是时间复杂度为O(n)，等同于顺序查找。因此，如果希望对一个集合按二叉排序树查找，最好是把它构建成一棵平衡的二叉排序树（平衡二叉树）。

  • 小结：
    • 二叉排序树是以链接的方式存储，保持了链接存储结构在执行插入或删除操作时不用移动元素的优点。只要找到合适的插入和删除位置后，仅需要修改链接指针即可。插入删除的时间性能比较好。
    • 对于二叉排序树的查找，走的是根结点到要查找结点的路径，其比较次数等于给定值的结点在二叉排序树的层次。
    • 注意：如果在建立二叉排序树的时候输入的序列是有序的，那么建立的二叉排序树将是一棵斜的树，此时查找性能最差，等于线性查找。

参考资料：

[1] https://www.jianshu.com/p/c6cb2c1460d0

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/502706
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号