• 数据结构与算法【二叉搜索树】Java实现

     介绍

    二叉搜索树（也称二叉排序树）是符合下面特征的二叉树：

    1. 树节点增加 key 属性，用来比较谁大谁小，key 不可以重复
    2. 对于任意一个树节点，它的 key 比左子树的 key 都大，同时也比右子树的 key 都小

    查找、插入、删除的时间复杂度与树高相关

    • 如果这棵树左右平衡，那么时间复杂度均是 O(logN)
    • 这棵树如果左右高度相差过大，那么这时是最糟的情况，相当于线性查找。时间复杂度是 O(N)。

    普通二叉搜索树

    1. public class BSTreeextends Comparable, V> {
    2.     public BSNode root;
    3.  
    4.     static class BSNode {
    5.         K key;
    6.         V value;
    7.         BSNode left;
    8.         BSNode right;
    9.  
    10.         public BSNode(K key) {
    11.             this.key = key;
    12.         }
    13.  
    14.         public BSNode(K key, V value) {
    15.             this.key = key;
    16.             this.value = value;
    17.         }
    18.  
    19.         public BSNode(K key, V value, BSNode left, BSNode right) {
    20.             this.key = key;
    21.             this.value = value;
    22.             this.left = left;
    23.             this.right = right;
    24.         }
    25.     }
    26. }

    实现通过key获取值

    1. public V get(K key) {
    2.     BSNode node = root;
    3.     while (node != null) {
    4.         //当传过来的key为null时会报错
    5.         int result = key.compareTo(node.key);
    6.         if (result < 0) {
    7.             //说明key
    8.             node = node.left;
    9.         } else if (result > 0) {
    10.             node = node.right;
    11.         } else {
    12.             return node.value;
    13.         }
    14.     }
    15.     return null;
    16. }

    实现获取最小key的值

    任何节点的左孩子一定比该节点小，因此当遍历到没有左孩子时说明是key最小的节点

    1. public V min() {
    2.     if (root == null) {
    3.         return null;
    4.     }
    5.     BSNode node = root;
    6.     while (node.left != null) {
    7.         node = node.left;
    8.     }
    9.     return node.value;
    10. }

    实现获取最大key的值

    任何节点的右孩子一定比该节点大，因此当遍历到没有右孩子时说明是key最大的节点

    1. public V max() {
    2.     if (root == null) {
    3.         return null;
    4.     }
    5.     BSNode node = root;
    6.     while (node.right != null) {
    7.         node = node.right;
    8.     }
    9.     return node.value;
    10. }

    实现新增节点

    如果key在二叉搜索树中不存在时，进行新增，如果存在则进行值覆盖

    1. public void put(K key, V value) {
    2.     BSNode node = root;
    3.     BSNode parent = null;
    4.     int result = 0;
    5.     while (node != null) {
    6.         parent = node;
    7.         result = key.compareTo(node.key);
    8.         if (result < 0) {
    9.             //说明key
    10.             node = node.left;
    11.         } else if (result > 0) {
    12.             node = node.right;
    13.         } else {
    14.             //如果存在该节点就覆盖
    15.             node.value = value;
    16.             return;
    17.         }
    18.     }
    19.  
    20.     //说明此时没有节点
    21.     if (parent == null){
    22.         root = new BSNode(key,value);
    23.     }else if (result<0){
    24.         parent.left = new BSNode(key, value);
    25.     }else {
    26.         parent.right = new BSNode(key, value);
    27.     }
    28. }

    实现获取前驱节点

    最简单的实现方式，是进行一次中序遍历，这样可以直接到获取一个升序的排序结果。但是效率较差，因此我们采用别的实现方案。

    找前驱节点，可以根据两个规律去实现

    • 节点有左子树，此时前驱节点就是左子树的最大值
    • 节点没有左子树，若离它最近的祖先自从左而来，此祖先即为前驱
    1. public V predecessor(K key) {
    2.     //祖先节点
    3.     BSNode ancestorFromLeft = null;
    4.     BSNode node = root;
    5.     while (node != null) {
    6.         int result = key.compareTo(node.key);
    7.         if (result < 0) {
    8.             node = node.left;
    9.         } else if (result > 0) {
    10.             //如果进入该分支，说明该节点可以作为一个祖先节点
    11.             ancestorFromLeft = node;
    12.             node = node.right;
    13.         } else {
    14.             break;
    15.         }
    16.     }
    17.     if (node==null){
    18.         //说明没有该节点
    19.         return null;
    20.     }
    21.     //如果存在左孩子
    22.     if (node.left!=null){
    23.         return max(node.left);
    24.     }
    25.     //如果不存在左孩子
    26.     return ancestorFromLeft!=null?ancestorFromLeft.value:null;
    27. }

    实现获取后驱节点

    与获取前驱节点类似，也可以通过中序遍历拿到排序结果后，寻找指定节点的后驱节点。也可以通过以下两个规律来实现

    • 节点有右子树，此时后继节点即为右子树的最小值
    • 节点没有右子树，若离它最近的祖先自从右而来，此祖先即为后继
    1. public V successor(K key){
    2.     //祖先节点
    3.     BSNode ancestorFromLeft = null;
    4.     BSNode node = root;
    5.     while (node != null) {
    6.         int result = key.compareTo(node.key);
    7.         if (result < 0) {
    8.             //如果进入该分支，说明该节点可以作为一个祖先节点
    9.             ancestorFromLeft = node;
    10.             node = node.left;
    11.         } else if (result > 0) {
    12.             node = node.right;
    13.         } else {
    14.             break;
    15.         }
    16.     }
    17.     if (node==null){
    18.         //说明没有该节点
    19.         return null;
    20.     }
    21.     //如果存在左孩子
    22.     if (node.right!=null){
    23.         return min(node.right);
    24.     }
    25.     //如果不存在左孩子
    26.     return ancestorFromLeft!=null?ancestorFromLeft.value:null;
    27. }

    实现删除指定节点

    删除节点比较麻烦。需要考虑4种情况

    • 被删除节点只存在左孩子
    • 被删除节点只存在右孩子
    • 被删除节点是根节点
    • 被删除节点存在两个孩子节点

    前两种情况可以通过被删除节点的父结点来继承被删除节点的子节点来实现。而后两种情况则需要找到被删除节点的后驱节点来顶替被删除节点的位置

    1.     public V delete(K key) {
    2.         //找到被删除节点
    3.         BSNode deleteNode = root;
    4.         //找到被删除节点的父结点
    5.         BSNode parent = null;
    6.         while (deleteNode != null) {
    7.             int result = key.compareTo(deleteNode.key);
    8.             if (result < 0) {
    9.                 //说明key
    10.                 parent = deleteNode;
    11.                 deleteNode = deleteNode.left;
    12.             } else if (result > 0) {
    13.                 parent = deleteNode;
    14.                 deleteNode = deleteNode.right;
    15.             } else {
    16.                 break;
    17.             }
    18.         }
    19.         if (deleteNode == null) {
    20.             //没找到该节点
    21.             return null;
    22.         }
    23.         //当要删除的节点只存在左节点时
    24.         if (deleteNode.right == null) {
    25.             shift(parent, deleteNode, deleteNode.left);
    26.         } else if (deleteNode.left == null) { //当要删除的节点只存在右节点时
    27.             shift(parent, deleteNode, deleteNode.right);
    28.         } else { //当要删除的节点存在两个子节点时，需要找到要删除节点的后驱节点
    29.             //后驱节点
    30.             BSNode s = deleteNode.right;
    31.             //后驱节点的父亲节点。用来判断被删除的节点与其后驱节点是否相邻
    32.             BSNode sParent = null;
    33.             while (s.left != null) {
    34.                 sParent = s;
    35.                 s = s.left;
    36.             }
    37.             //如果要删除的节点与后驱节点不相邻
    38.             if (sParent != deleteNode) {
    39.                 //将后驱节点的子节点交给后驱节点的父结点
    40.                 shift(sParent, s, s.right);
    41.                 //后驱节点接管被删除节点的右孩子
    42.                 s.right = deleteNode.right;
    43.             }
    44.             //如果要删除的节点与后驱节点相邻
    45.             shift(parent,deleteNode,s);
    46.             //后驱节点顶替被删除节点的位置
    47.             s.left = deleteNode.left;
    48.         }
    49.         return deleteNode.value;
    50.     }
    51.  
    52.     /**
    53.      * 将要删除的节点的子节点转移到其父结点上
    54.      *
    55.      * @param parent     父结点
    56.      * @param deleteNode 要删除的节点
    57.      * @param child      子节点
    58.      */
    59.     private void shift(BSNode parent, BSNode deleteNode, BSNode child) {
    60.         if (parent == null) {
    61.             //说明要删除的节点为根节点
    62.             root = child;
    63.         } else if (deleteNode.left == child) {
    64.             //如果要删除的节点只存在左节点
    65.             parent.left = child;
    66.         }else {
    67.             parent.right = child;
    68.         }
    69.     }

    实现范围查询

    采用中序遍历得到排序结果后，将符合范围的节点返回一个集合

    1. //查找小于key的所有节点的value
    2. public List less(K key) {
    3.     List result = new ArrayList<>();
    4.     LinkedList> linked = new LinkedList<>();
    5.     BSNode node = root;
    6.     while (node != null || !linked.isEmpty()) {
    7.         if (node != null) {
    8.             linked.push(node);
    9.             node = node.left;
    10.         } else {
    11.             BSNode pop = linked.pop();
    12.             int compare = key.compareTo(pop.key);
    13.             //如果比指定值小
    14.             if (compare > 0) {
    15.                 //加入列表
    16.                 result.add(pop.value);
    17.             } else {
    18.                 //如果比指定值大，没有接着循环的必要
    19.                 break;
    20.             }
    21.             node = pop.right;
    22.         }
    23.     }
    24.     return result;
    25. }

    可以自己实现一下>key或是k1<=values<=k2的代码。

    平衡二叉搜索树

    如果普通二叉搜索树不平衡的情况下，最坏情况下查询与线性查询没有区别。如下图所示

    因此，我们可以通过旋转来使一棵不平衡的二叉树变得平衡

    失衡条件

    如果一个节点的左右孩子，高度差超过 1，则此节点失衡，才需要旋转

    解决方法

    失衡存在以下四种情况：

    LL：失衡节点的左子树更高（L），失衡节点的左孩子的左子树等高或更高（L）

    LR：失衡节点的左子树更高（L），失衡节点的左孩子的右子树更高（R）

    RL：失衡节点的右子树更高（R），失衡节点的右孩子的左子树更高（L）

    RR：失衡节点的右子树更高（R），失衡节点的右孩子的右子树等高或更高（R）

    这四种情况对应的旋转情况如下

    • LL：失衡节点右旋
    • LR：失衡节点的左子树左旋，之后失衡节点右旋（又叫左右旋）
    • RL：失衡节点的右子树右旋，之后失衡节点左旋（又叫右左旋）
    • RR：失衡节点右旋

    左右旋示例

    这是一个不平衡的二叉搜索树 

    左子树旋转后

    失衡节点右旋

    实现代码

    大体框架

    相比普通二叉搜索树，需要添加一个新的属性height来记录当前节点高度

    1. public class AVLTree {
    2.  
    3.     private AVLNode root;
    4.  
    5.     static class AVLNode {
    6.         //树高度
    7.         int height = 1;
    8.         int key;
    9.         Object value;
    10.         AVLNode left;
    11.         AVLNode right;
    12.  
    13.         public AVLNode(int key, Object value) {
    14.             this.key = key;
    15.             this.value = value;
    16.         }
    17.  
    18.         public AVLNode(int key, Object value, AVLNode left, AVLNode right) {
    19.             this.key = key;
    20.             this.value = value;
    21.             this.left = left;
    22.             this.right = right;
    23.         }
    24.     }
    25. }

    高度查询及更新代码

    1. //获取高度
    2. private int height(AVLNode node) {
    3.     return node == null ? 0 : node.height;
    4. }
    5.  
    6. //更新高度。寻找子节点中较大的高度急+1即可
    7. private void updateHeight(AVLNode node) {
    8.     node.height = Integer.max(height(node.left), height(node.right)) + 1;
    9. }
    10.  
    11. //判断是否失衡。如果返回值为1、0、-1表示没有失衡
    12. private int bf(AVLNode node) {
    13.     return height(node.left) - height(node.right);
    14. }

    结点旋转代码

    1. /**
    2.  * 将指定节点右旋后返回新的父结点
    3.  *
    4.  * @param node
    5.  * @return
    6.  */
    7. public AVLNode rightRotate(AVLNode node) {
    8.     //要被旋转的节点去拿到新父节点的右孩子
    9.     AVLNode newParent = node.left;
    10.     node.left = newParent.right;
    11.     newParent.right = node;
    12.     //旋转过后需要修改节点高度。
    13.     //注意！必须先修改失衡节点。
    14. 	//因为在旋转后，失衡节点高度会下降，底层节点正确后才能更新上层节点
    15.     updateHeight(node);
    16.     updateHeight(newParent);
    17.     return newParent;
    18. }
    19.  
    20. /**
    21.  * 将指定节点左旋后返回新的父结点
    22.  *
    23.  * @param node
    24.  * @return
    25.  */
    26. public AVLNode leftRotate(AVLNode node) {
    27.     //要被旋转的节点去拿到新父节点的右孩子
    28.     AVLNode newParent = node.right;
    29.     node.right = newParent.left;
    30.     newParent.left = node;
    31.     updateHeight(node);
    32.     updateHeight(newParent);
    33.     return newParent;
    34. }
    35.  
    36. /**
    37.  * 左右旋后返回新的父结点
    38.  *
    39.  * @param node
    40.  * @return
    41.  */
    42. public AVLNode leftRightRotate(AVLNode node) {
    43.     //修改要被旋转节点的左孩子节点，相当于左旋左子树
    44.     node.left = leftRotate(node.left);
    45.     //右旋失衡节点
    46.     return rightRotate(node);
    47. }
    48.  
    49.  
    50. /**
    51.  * 右左旋后返回新的父结点
    52.  *
    53.  * @param node
    54.  * @return
    55.  */
    56. public AVLNode rightLeftRotate(AVLNode node) {
    57.     //修改要被旋转节点的右孩子节点，相当于右旋右子树
    58.     node.right = rightRotate(node.right);
    59.     //左旋失衡节点
    60.     return leftRotate(node);
    61. }

    判断节点是否失衡代码

    1. /**
    2.  * 判断节点是否失衡
    3.  * @param node
    4.  * @return
    5.  */
    6. public AVLNode balance(AVLNode node){
    7.     if (node == null){
    8.         return null;
    9.     }
    10.     int bf = bf(node);
    11.     //如果失衡节点的左子树高，此时属于L
    12.     if (bf>1){
    13.         if (bf(node.left)>=0){
    14.             //此时属于LL
    15.             return rightRotate(node);
    16.         }else {
    17.             //此时属于LR
    18.             return leftRightRotate(node);
    19.         }
    20.     }else if (bf<-1){//此时属于R
    21.         if (bf(node.right)>=0){
    22.             //此时属于RR
    23.             return leftRotate(node);
    24.         }else {
    25.             //此时属于RL
    26.             return rightLeftRotate(node);
    27.         }
    28.     }
    29.     //不失衡，直接返回
    30.     return node;
    31. }

    新增节点代码

    1. /**
    2.  * 新增节点
    3.  * @param key
    4.  * @param value
    5.  */
    6. public void put(int key, Object value) {
    7.     root = doPut(root, key, value);
    8. }
    9.  
    10. private AVLNode doPut(AVLNode node, int key, Object value) {
    11.     if (node == null) {
    12.         return new AVLNode(key, value);
    13.     }
    14.     if (key == node.key) {
    15.         node.value = value;
    16.         return node;
    17.     }
    18.     if (key < node.key) {
    19.         node.left = doPut(node.left, key, value);
    20.     } else {
    21.         node.right = doPut(node.right, key, value);
    22.     }
    23.     //更新高度
    24.     updateHeight(node);
    25.     //判断是否失衡
    26.     return balance(node);
    27. }

    删除节点代码

    1. /**
    2.  * 删除节点
    3.  * @param key
    4.  * @return
    5.  */
    6. public void remove(int key) {
    7.     root = doRemove(root, key);
    8. }
    9.  
    10. private AVLNode doRemove(AVLNode node, int key) {
    11.     if (node == null) {
    12.         return null;
    13.     }
    14.     if (key < node.key) {
    15.         node.left = doRemove(node.left, key);
    16.     } else if (node.key < key) {
    17.         node.right = doRemove(node.right, key);
    18.     } else {
    19.         //找到要删除的节点了
    20.         if (node.left == null) {
    21.             //如果左边为null。那么右边节点顶替被删除节点
    22.             node = node.right;
    23.         } else if (node.right == null) {
    24.             //如果右边为空，那么左边节点顶替被删除节点
    25.             node = node.left;
    26.         } else {
    27.             //如果均不为null。那么找到后驱节点
    28.             AVLNode s = node.right;
    29.             while (s.left != null) {
    30.                 s = s.left;
    31.             }
    32.             //后驱节点的右孩子为被删除节点的右孩子
    33.             s.right = doRemove(node.right, s.key);
    34.             s.left = node.left;
    35.             //将后驱节点替代被删除节点
    36.             node = s;
    37.         }
    38.     }
    39.     updateHeight(node);
    40.     return balance(node);
    41. }

    总结

    AVL树的优点：

    1. AVL树是一种自平衡树，保证了树的高度平衡，从而保证了树的查询和插入操作的时间复杂度均为O(logn)。
    2. 相比于一般二叉搜索树，AVL树对查询效率的提升更为显著，因为其左右子树高度的差值不会超过1，避免了二叉搜索树退化为链表的情况，使得整棵树的高度更低。
    3. AVL树的删除操作比较简单，只需要像插入一样旋转即可，在旋转过程中树的平衡性可以得到维护。

    AVL树的缺点：

    1. AVL树每次插入或删除节点时需要进行旋转操作，这个操作比较耗时，因此在一些应用中不太适用。
    2. 在AVL树进行插入或删除操作时，为保持树的平衡需要不断进行旋转操作，在一些高并发环节和大数据量环境下，这可能会导致多余的写锁导致性能瓶颈。
    3. AVL树的旋转操作相对较多，因此在一些应用中可能会造成较大的空间浪费。

     

  • 相关阅读:
    C++拷贝、赋值、移动、析构、默认构造 什么时候会被默认生成delete
    虚拟化技术介绍——HCIA Cloud
    力扣每日一题61：旋转链表
    linux篇【6】：进程等待
    win11开机死机解决教程
    【1++的C++进阶】之emplace详解
    Protobuf 和JSON 性能分析
    Ubuntu下C/C++开发小结
    2024 ，Android 15 预览版来了
    C++ std::future
  • 原文地址：https://blog.csdn.net/zmbwcx/article/details/134496000