【数据结构】二叉搜索树的模拟实现

目录

1、概念

2、模拟实现

2.1、查找

2.2、插入

2.3、删除（难点）

3、性能分析

 4、完整代码


 

1、概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树

Java底层实现搜索树的两个主要类是TreeSet和TreeMap。

        TreeSet是基于红黑树（Red-Black tree）实现的，它提供了对元素的唯一性排序。TreeSet中的元素是唯一的，并且按照升序排序。

        TreeMap也是基于红黑树实现的，它提供了一个键值对的映射关系，并且按照键的升序排序。TreeMap允许使用null键和null值。

        这两个类都实现了NavigableMap和SortedMap接口，提供了更丰富的方法用于搜索、排序和遍历操作。

        为了更好的理解TreeSet和TreeMap的使用以及底层原理，下面带大家模拟实现一下搜索树。

2、模拟实现

2.1、查找

 若根节点不为空：

  • 如果根节点key==查找key，返回true
  • 如果根节点key > 查找key，去其左子树上查找
  • 如果根节点key < 查找key，去其右子树上查找

否则返回false

  1.     public boolean search(int val) {
  2.         TreeNode cur = root;
  3.         while (cur != null) {
  4.             if (cur.val > val) {   //当前节点大于val，去左子树上继续找
  5.                 cur = cur.left;
  6.             } else if (cur.val < val) {   //当前节点小于val，去右子树上继续找
  7.                 cur = cur.right;
  8.             } else {
  9.                 return true;   //找到返回true
  10.             }
  11.         }
  12.         return false;
  13.     }

2.2、插入

插入时分为两种大情况：树为空以及树不为空

1、如果树为空树，即根 == null，直接插入

2、如果树不是空树，按照查找逻辑确定插入位置，插入新结点

  1.     public void insert(int val) {
  2.         if (root == null) {    //树为空时直接插入并返回
  3.             root = new TreeNode(val);
  4.             return;
  5.         }
  6.         TreeNode cur = root;
  7.         TreeNode prev = null;    //指向cur前一个节点（即父亲节点），用于最终插入时使用
  8.         while (cur != null) {
  9.             prev = cur;      //更新prev指向
  10.             if (cur.val > val) {
  11.                 cur = cur.left;
  12.             } else if (cur.val < val) {
  13.                 cur = cur.right;
  14.             } else {
  15.                 return;  //遇到相同退出,无需重复插入
  16.             }
  17.         }
  18.         if (prev.val > val) {    //判断插入的正确位置
  19.             prev.left = new TreeNode(val);
  20.         } else {
  21.             prev.right = new TreeNode(val);
  22.         }
  23.  
  24.     }

2.3、删除（难点）

删除操作是二叉搜索树三种基本操作中最难的一个操作，它的难点不在于代码的难度，而是因为涉及到的情况居多，稍微不注意就容易漏判断某一条情况，因此使用合理的思路去理解记忆二叉搜索树的删除操作是非常必要的。

 设待删除结点为 cur, 待删除结点的双亲结点为 prev。对cur删除节点的三种情况进行分析：

1. cur.left == null

  • cur 是 root，则 root = cur.right
  • cur 不是 root，cur 是 prev.left，则 prev.left = cur.right
  • cur 不是 root，cur 是 prev.right，则 prev.right = cur.right

2. cur.right == null

  • cur 是 root，则 root = cur.left
  • cur 不是 root，cur 是 prev.left，则 prev.left = cur.left
  • cur 不是 root，cur 是 prev.right，则 prev.right = cur.left

3. cur.left != null && cur.right != null

需要使用替换法进行删除。

替换法的核心是：找到删除节点左子树中的最大值（即子树中的最右节点，这个节点一定没有右右子树），或者删除节点右子树中的最小值（即子树中的最左节点，这个节点一定没有左子树），用它的值填补到被删除节点中，再来处理该结点的删除问题。

以下讲解使用替换删除节点右子树的最小节点：

首先找到最小节点tmp，以及最小节点的父亲tmpPrev，如图所示结构，紧着cur.val = tmp.val替换值，然后删除tmp节点，删除步骤如图所示，即tmpPrev.left = tmp.right。

值得注意的是，有一种情况会被忽略，即当cur.right 节点无左子树时，此时tmpPrev仍然是cur，而tmp即为cur.right，此时删除tmp节点的步骤就变为了tmpPrev.right = tmp.right 

 

  1.     public void remove(int val) {
  2.         TreeNode cur = root;
  3.         TreeNode prev = null;
  4.         while (cur != null) {
  5.             prev = cur;
  6.             if(cur.val > val) {
  7.                 cur = cur.left;
  8.             } else if (cur.val < val){
  9.                 cur = cur.right;
  10.             } else {
  11.                 removeNode(cur,prev);
  12.                 return;
  13.             }
  14.         }
  15.     }
  16.  
  17.     public void removeNode(TreeNode cur, TreeNode prev) {
  18.         if(cur.left == null) {
  19.  
  20.             if(cur == root) {
  21.                 root = cur.right;
  22.             } else if (prev.left == cur) {
  23.                 prev.left = cur.right;
  24.             } else {
  25.                 prev.right = cur.right;
  26.             }
  27.  
  28.         } else if (cur.right == null) {
  29.  
  30.             if(cur == root) {
  31.                 root = cur.left;
  32.             } else if (prev.left == cur) {
  33.                 prev.left = cur.left;
  34.             } else {
  35.                 prev.right = cur.left;
  36.             }
  37.  
  38.         } else {
  39.  
  40.             TreeNode tmp = cur.right;
  41.             TreeNode tmpPrev = cur;
  42.             while(tmp.left != null) {
  43.                 tmpPrev = tmp;
  44.                 tmp = tmp.left;
  45.             }
  46.             cur.val = tmp.val;
  47.  
  48.             //注意，可能没有进入while循环，此时这里的两种情况
  49.             if (tmpPrev.left == tmp) {
  50.                 tmpPrev.left = tmp.right;
  51.             } else {
  52.                 tmpPrev.right = tmp.right;
  53.             }
  54.  
  55.  
  56.         }
  57.     }

3、性能分析

  • 插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
  • 对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
  • 但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

 

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log2⁡N" role="presentation" style="position: relative;">log2⁡N

最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N2" role="presentation" style="position: relative;">N2

如果退化成单支树，二叉搜索树的性能就失去了，而为了改进这一缺陷，就有了AVL树。

AVL树是最先发明的自平衡二叉搜索树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

本篇博客的重点不在AVL树上，因此不对AVL树进行展开讲解，可自行搜索了解。 

 4、完整代码

  1. package BinarySearchTree;
  2.  
  3.  
  4. public class BinarySearchTree {
  5.     static class TreeNode {
  6.         public int val;
  7.         public TreeNode left;
  8.         public TreeNode right;
  9.  
  10.         public TreeNode(int val) {
  11.             this.val = val;
  12.         }
  13.     }
  14.  
  15.     public TreeNode root;
  16.  
  17.     public boolean search(int val) {
  18.         TreeNode cur = root;
  19.         while (cur != null) {
  20.             if (cur.val > val) {
  21.                 cur = cur.left;
  22.             } else if (cur.val < val) {
  23.                 cur = cur.right;
  24.             } else {
  25.                 return true;
  26.             }
  27.         }
  28.         return false;
  29.     }
  30.  
  31.     public void insert(int val) {
  32.         if (root == null) {
  33.             root = new TreeNode(val);
  34.             return;
  35.         }
  36.         TreeNode cur = root;
  37.         TreeNode prev = null;
  38.         while (cur != null) {
  39.             prev = cur;
  40.             if (cur.val > val) {
  41.                 cur = cur.left;
  42.             } else if (cur.val < val) {
  43.                 cur = cur.right;
  44.             } else {
  45.                 return;  //相同退出
  46.             }
  47.         }
  48.         if (prev.val > val) {
  49.             prev.left = new TreeNode(val);
  50.         } else {
  51.             prev.right = new TreeNode(val);
  52.         }
  53.  
  54.     }
  55.  
  56.     public void remove(int val) {
  57.         TreeNode cur = root;
  58.         TreeNode prev = null;
  59.         while (cur != null) {
  60.             prev = cur;
  61.             if(cur.val > val) {
  62.                 cur = cur.left;
  63.             } else if (cur.val < val){
  64.                 cur = cur.right;
  65.             } else {
  66.                 removeNode(cur,prev);
  67.                 return;
  68.             }
  69.         }
  70.     }
  71.  
  72.     public void removeNode(TreeNode cur, TreeNode prev) {
  73.         if(cur.left == null) {
  74.  
  75.             if(cur == root) {
  76.                 root = cur.right;
  77.             } else if (prev.left == cur) {
  78.                 prev.left = cur.right;
  79.             } else {
  80.                 prev.right = cur.right;
  81.             }
  82.  
  83.         } else if (cur.right == null) {
  84.  
  85.             if(cur == root) {
  86.                 root = cur.left;
  87.             } else if (prev.left == cur) {
  88.                 prev.left = cur.left;
  89.             } else {
  90.                 prev.right = cur.left;
  91.             }
  92.  
  93.         } else {
  94.  
  95.             TreeNode tmp = cur.right;
  96.             TreeNode tmpPrev = cur;
  97.             while(tmp.left != null) {
  98.                 tmpPrev = tmp;
  99.                 tmp = tmp.left;
  100.             }
  101.             cur.val = tmp.val;
  102.  
  103.             //注意当没有进入while循环时这里的两种情况
  104.             if (tmpPrev.left == tmp) {
  105.                 tmpPrev.left = tmp.right;
  106.             } else {
  107.                 tmpPrev.right = tmp.right;
  108.             }
  109.  
  110.  
  111.         }
  112.     }
  113. }

 【博主推荐】

【LeetCode力扣】面试题 17.14. 最小K个数（top-k问题）-CSDN博客icon-default.png?t=N7T8http://iyenn.com/rec/2137786.html?spm=1001.2014.3001.5501【LeetCode力扣】42. 接雨水-CSDN博客icon-default.png?t=N7T8http://iyenn.com/rec/1635541.html?spm=1001.2014.3001.5501【LeetCode力扣】189 53 轮转数组 | 最大子数组和-CSDN博客icon-default.png?t=N7T8http://iyenn.com/rec/1582255.html?spm=1001.2014.3001.5501

如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！

如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！

如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！

注：本文转载自blog.csdn.net的Hacynn的文章"https://blog.csdn.net/zzzzzhxxx/article/details/135910604"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！