devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

平衡二叉树（AVL）插入结点后的再平衡思路_avl树再平衡的方法

作者：小小林熬夜学编程 | 2024-04-30 05:09:08

赞

踩

avl树再平衡的方法

理解平衡二叉树

在解决平衡二叉树动平衡问题，我们先来明确什么是平衡二叉树：

平衡二叉树是二叉搜索树的一种特殊情况，所以在二叉搜索树的基础上加上了如下定义：

平衡因子：我们将二叉树中各个结点的左右子树的高度差称为该节点的平衡因子。

平衡二叉树：就是在二叉搜索树的基础上，所有结点的平衡因子都小于等于一。则称该树为一颗平衡二叉树。

当然平衡二叉树有很多实现方案，例如：AVL、红黑树等。这篇文章还是以最基础的AVL方式实现一个自平衡二叉树。

例如：

在上图中10节点左子树高度为2,10的右子树高度为1，同样的我们查看5号结点的平衡因子等于0,15号结点的平衡因子为0，4号结点.............所以这棵树为平衡二叉树。

规律：当我们插入节点时，我们可以发现这么一个规律，被破坏平衡的节点最近也是插入节点的爷爷结点。

例：这棵树本来是一个平衡二叉树，如果我们插入一个值为6的结点，那么10号结点的平衡因子就会大于1，那么

这树就变得不平衡了。不平衡的节点为10，是6的爷爷结点。这是最极端的情况，不可能找到插入节点使得父结点不平衡的情况。（这句话自己好好体会）


插入节点的再平衡的解决思路

在AVL中采用节点的旋转使得树再平衡，二叉搜索树中节点的旋转不会破坏二叉搜索树的规则。

而平衡二叉树插入节点后导致平衡性被破坏，分为下面几种情况：（红色为不平衡节点，蓝色为刚刚插入的节点）

左左型：

 

右右型：

右左型：

左右型：

上面四种情况的再平衡需要做不同的讨论：

 

左左型的再平衡：

对于左左型，我们需要以被破坏平衡的节点为中心顺时针旋转，这样既没有破坏二叉搜索树的规则还，使得树再次平衡了。

这里我们举个栗子：

我们给定一个平衡二叉树：

现在我们插入一个值为1的结点：

此时导致节点为10的结点不平衡，而此时3、5、10节点正好形成左左型不平衡。按照上面的思路，我们需要以被破坏平衡的结点的位置为中心，旋转元素。

此时我们需要注意6号结点，该节点原先在5号结点的右孩子，但是由于旋转后原先的父节点肯定是5好节点的右孩子，占了5号结点的位置，但是又与10号结点被旋转后左孩子为空，我们刚好可以把它加入10结点的左孩子上（符合二叉搜索树的左小右大原则）。这样二叉树再次平衡了。

同样的右右型原理与左左型相同，此处不再赘述。

 

左右型的再平衡：

   对于左右型，我们需要将破坏平衡结点的孩子节点和孙子节点进行逆时针旋转，这样就将问题又转换成了左左型。

此时我们只需要重复上面的左左型操作即可。

我们还是来举个栗子：

还是上面给出的那个平衡二叉树：

现在我们想要插入一个值为7的节点：

此时由于7号结点加入，10号几点变得不平衡了，而5、9、10节点也形成了“左右型”。此时我们只需要以10的孩子结点5的位置为中心，逆时针旋转。

此时问题转换成“左左型”的问题了（注意），那我们此时已10号结点为中心顺时针旋转即可解决这个问题

 

思路总结

在插入节点后我们需要以插入的节点为起点，向上寻找第一个不平衡节点，然后判断这个不平衡节点在不平衡路径上是哪种状态，然后根据不同的状态进行调整，如果是左左型或是右右型只需经过一次旋转即可，如果是左右型或者右左型需要先旋转一次将其转换成左左型或者右右型，然后再旋转一次即可使得二叉树平衡。

代码实现

二叉搜索树的实现：

  1. public class MyBinarySearchTree {
  2.     public static class Node {
  3.         public int value;
  4.         public Node lchild;
  5.         public Node rchild;
  6.         public Node parent;
  7.  
  8.         public Node(int value) {
  9.             this.value = value;
  10.         }
  11.     }
  12.  
  13.     protected Node root;
  14.  
  15.     private int size = 0;
  16.  
  17.     public void insert(int value) {
  18.         Node insertNode = new Node(value);
  19.         if (root == null) {
  20.             root = insertNode;
  21.         } else {
  22.             Node node = root;
  23.             while (true) {
  24.                 if (value < node.value) {
  25.                     if (node.lchild == null) {
  26.                         node.lchild = insertNode;
  27.                         insertNode.parent = node;
  28.                         break;
  29.                     }
  30.                     node = node.lchild;
  31.                 } else {
  32.                     if (node.rchild == null) {
  33.                         node.rchild = insertNode;
  34.                         insertNode.parent = node;
  35.                         break;
  36.                     }
  37.                     node = node.rchild;
  38.                 }
  39.             }
  40.         }
  41.         size++;
  42.     }
  43.  
  44.     /**
  45.      * 中序遍历
  46.      */
  47.     public List<Integer> inorderTree() {
  48.         List<Integer> list = new LinkedList<>();
  49.         inorderTree(list, root);
  50.         return list;
  51.     }
  52.  
  53.     private void inorderTree(List<Integer> list, Node node) {
  54.         if (node != null) {
  55.             inorderTree(list, node.lchild);
  56.             list.add(node.value);
  57.             inorderTree(list, node.rchild);
  58.         }
  59.  
  60.     }
  61.  
  62.     public Node getNode(int value) {
  63.         Node node = root;
  64.         Node result = null;
  65.         while (node != null) {
  66.             if (node.value == value) {
  67.                 result = node;
  68.                 break;
  69.             } else {
  70.                 if (value < node.value) {
  71.                     node = node.lchild;
  72.                 } else {
  73.                     node = node.rchild;
  74.                 }
  75.             }
  76.         }
  77.         return result;
  78.     }
  79.  
  80.     public Integer min() {
  81.         return min(root).value;
  82.     }
  83.  
  84.     public Node min(Node node) {
  85.         if (node != null) {
  86.             while (node.lchild != null) {
  87.                 node = node.lchild;
  88.             }
  89.             return node;
  90.         }
  91.         return null;
  92.     }
  93.  
  94.     public Integer max() {
  95.         Node node = root;
  96.         if (node != null) {
  97.             while (node.rchild != null) {
  98.                 node = node.rchild;
  99.             }
  100.             return node.value;
  101.         }
  102.         return null;
  103.     }
  104.  
  105.     /**
  106.      * 删除节点
  107.      *
  108.      * @param value
  109.      */
  110.     public void remove(int value) {
  111.         /**
  112.          * 解题思路：删除节点要分为三种情况
  113.          *
  114.          * 情况一：删除叶子节点  好解决
  115.          * 情况二：删除单分支节点  由后面的元素顶替要删除的元素即可
  116.          * 情况三：删除双分支节点，这种情况是最不好想的
  117.          *       这种情况需要找到左子树最大的节点或右子树最小的节点顶上去。
  118.          */
  119.         Node node = this.getNode(value);
  120.         if (node != null) {
  121.             //当节点为叶子节点
  122.             if (node.lchild == null && node.rchild == null) {
  123.                 //要删除的节点为根节点
  124.                 if (node.parent == null) {
  125.                     root = null;
  126.                 }else{
  127.                     //判断当前节点是父节点的左孩子还是右孩子
  128.                     if (node.parent.rchild == node) {
  129.                         node.parent.rchild = null;
  130.                     } else {
  131.                         node.parent.lchild = null;
  132.                     }
  133.                     node.parent = null;
  134.                 }
  135.             } else if (node.lchild == null || node.rchild == null) {
  136.                 //当该节点为单分支节点
  137.  
  138.                 //找到在单分支情况下,唯一的那个孩子节点
  139.                 Node childen = null;
  140.                 if (node.lchild != null) {
  141.                     childen = node.lchild;
  142.                     node.lchild = null;
  143.                 } else {
  144.                     childen = node.rchild;
  145.                     node.rchild = null;
  146.                 }
  147.  
  148.                 //如果要删除的节点为根节点
  149.                 if (node.parent == null) {
  150.                     root = childen;
  151.                 }else {
  152.                     childen.parent = node.parent;
  153.                     //同样的需要先判断当前节点是父节点的左孩子还是右孩子
  154.                     if (node.parent.rchild == node) {
  155.                         node.parent.rchild = childen;
  156.                     } else {
  157.                         node.parent.lchild = childen;
  158.                     }
  159.                 }
  160.             } else {
  161.                 //双分支情况
  162.                 //获取右分支最小的节点
  163.                 Node minNode = min(node.rchild);
  164.  
  165.                 //采用递归法删除最小的那个节点，为什么可以使用递归删除呢，因为前面获得的右分支中的最小节点，
  166.                 //一定是叶子节点，或者向右倾斜的单分支节点，所以采用递归删除即可（前面的步骤不就用于删除这两种情况的吗）。
  167.                 this.remove(minNode.value);
  168.  
  169.                 //将已经被删除的“右子树最小值”的结点的值附到需要删除的值的节点上，这样就从表象上完成了对指定节点的删除
  170.                 node.value = minNode.value;
  171.             }
  172.         }
  173.     }
  174.  
  175.     /**
  176.      * 获取当前Node的后继元素，即比当前Node的值大，但最接近当前Node值的结点（或者说是获得中序遍历的下一个元素）
  177.      * @param node
  178.      * @return
  179.      */
  180.     public Node nextValue(Node node){
  181.         /**
  182.          * 解题思路：在通常情况下后继结点就是右子树中最大的元素，但是如果没有右子树那就复杂了，
  183.          * 那后继结点就是依次遍历父结点，将自己作为左子树的第一个父结点就是我们找的后继结点。
  184.          */
  185.         if (node != null) {
  186.             if (node.rchild != null) {
  187.                 return min(node.rchild);
  188.             }else{
  189.                 while (node !=null && node.parent.rchild == node){
  190.                     node = node.parent;
  191.                 }
  192.                 return node.parent;
  193.             }
  194.         }
  195.         return null;
  196.     }
  197.  
  198.     public boolean isBalance() {
  199.         return false;
  200.     }
  201.  
  202.     public int size() {
  203.         return size;
  204.     }
  205.  
  206.     public int getHeight(Node node) {
  207.         if(node != null){
  208.             if(node.lchild == null && node.rchild == null){
  209.                 return 0;
  210.             }else{
  211.                 return 1+Math.max(getHeight(node.lchild),getHeight(node.rchild));
  212.             }
  213.         }
  214.         return -1;
  215.     }
  216.  
  217.     public int getHeight() {
  218.         return this.getHeight(root);
  219.     }
  220.  
  221.     /**
  222.      * 判断当前节点是否是父节点的右孩子，如果没有父节点则返回null
  223.      * @param node
  224.      * @return
  225.      */
  226.     public static Boolean isRchild(Node node){
  227.         if(node != null && node.parent != null){
  228.             if(node.parent.rchild == node){
  229.                 return true;
  230.             }
  231.             return false;
  232.         }else{
  233.             return null;
  234.         }
  235.     }
  236.  
  237.     /**
  238.      * 判断当前节点是否是父节点的左孩子，如果没有父节点则返回null
  239.      * @param node
  240.      * @return
  241.      */
  242.     public static Boolean isLchild(Node node){
  243.         if(node != null && node.parent != null){
  244.             if(node.parent.lchild == node){
  245.                 return true;
  246.             }
  247.             return false;
  248.         }else{
  249.             return null;
  250.         }
  251.     }
  252. }

 

平衡二叉树的实现：（继承于二叉搜索树）

  1. public class MyBalanceTree extends MyBinarySearchTree {
  2.     /**
  3.      * 解题思路：平衡二叉树我们需要先插入节点，然后从插入节点往上找，找到第一个不平衡的节点，看这个不平衡的树是什么类型的
  4.      * 左左型 右右型
  5.      * 左右型 右左型
  6.      * <p>
  7.      * 我们将不平衡节点设为g 不平衡节点的孩子节点设置p p的孩子节点设为s
  8.      *
  9.      * @param value
  10.      */
  11.     @Override
  12.     public void insert(int value) {
  13.         //先插入节点，然后在调整树的平衡
  14.         super.insert(value);
  15.         //获得刚刚插入的节点
  16.         Node node = this.getNode(value);
  17.         Node[] unBalance = this.getFirstUnbalanceNode(node);
  18.         if (unBalance != null) {
  19.             this.reBalance(unBalance);
  20.         }
  21.     }
  22.  
  23.     /**
  24.      * 根据插入节点向上找到第一个未平衡节点
  25.      *
  26.      * @param node
  27.      * @return 返回的是一个数组，node[0]就是未平衡结点，node[1]是node[0]的孩子节点,node[2]是node[3]的孩子节点
  28.      * 这样做是为了还原未平衡节点与插入节点之间的路径，方便后面的旋转
  29.      */
  30.     private Node[] getFirstUnbalanceNode(Node node) {
  31.         Node g, p, s;
  32.         if (node != null && node.parent != null && node.parent.parent != null) {
  33.             s = node;
  34.             p = s.parent;
  35.             g = p.parent;
  36.             if (Math.abs(this.getHeight(g.lchild) - this.getHeight(g.rchild)) > 1) {
  37.                 return new Node[]{g, p, s};
  38.             } else {
  39.                 return getFirstUnbalanceNode(s.parent);
  40.             }
  41.         }
  42.         return null;
  43.     }
  44.  
  45.     private void reBalance(Node[] unBalance) {
  46.         if (unBalance == null || unBalance.length != 3) {
  47.             return;
  48.         }
  49.         Node g = unBalance[0];
  50.         Node p = unBalance[1];
  51.         Node s = unBalance[2];
  52.  
  53.         if (MyBinarySearchTree.isLchild(p) && MyBinarySearchTree.isLchild(s)) {//左左型
  54.             this.rightRevolve(g, p);
  55.         } else if (MyBinarySearchTree.isRchild(p) && MyBinarySearchTree.isRchild(s)) {//右右型
  56.             this.leftResolve(g, p);
  57.         } else if (MyBinarySearchTree.isLchild(p)) {//左右型
  58.             this.leftResolve(p, s);
  59.             this.rightRevolve(g, s);
  60.         } else {//右左型
  61.             this.rightRevolve(p, s);
  62.             this.leftResolve(g, s);
  63.         }
  64.     }
  65.  
  66.     /**
  67.      * 以center结点位置为中心右旋，旋转后，原先的child作为中心结点，原先的中心结点作为child右孩子
  68.      *
  69.      * @param center 旋转的中心节点
  70.      * @param child  中心节点的左孩子
  71.      */
  72.     private void rightRevolve(Node center, Node child) {
  73.         if (center == null) {
  74.             return;
  75.         }
  76.         if (child == null) {
  77.             return;
  78.         }
  79.         Node parent = center.parent;
  80.         if (parent == null) {//证明此时旋转的中心结点是root
  81.             root = child;
  82.             child.parent = null;
  83.             Node rchild = child.rchild;
  84.             child.rchild = center;
  85.             center.parent = child;
  86.             center.lchild = rchild;
  87.             if(rchild !=null){
  88.                 rchild.parent = center;
  89.             }
  90.         } else {
  91.             if (MyBinarySearchTree.isRchild(center)) {//中心结点是父节点的右孩子
  92.                 parent.rchild = child;
  93.             } else {
  94.                 parent.lchild = child;
  95.             }
  96.             child.parent = parent;
  97.             Node rchild = child.rchild;//需要将旋转前child的右孩子放到旋转后center的左节点中
  98.             child.rchild = center;
  99.             center.parent = child;
  100.             center.lchild = rchild;
  101.             if(rchild !=null){
  102.                 rchild.parent = center;
  103.             }
  104.         }
  105.  
  106.     }
  107.  
  108.     /**
  109.      * 以center结点位置为中心左旋，旋转后，原先的child作为中心结点，原先的中心结点作为child左孩子
  110.      *
  111.      * @param center 旋转的中心节点
  112.      * @param child  中心节点的右孩子
  113.      */
  114.     private void leftResolve(Node center, Node child) {
  115.         if (center == null) {
  116.             return;
  117.         }
  118.         if (child == null) {
  119.             return;
  120.         }
  121.         Node parent = center.parent;
  122.         if (parent == null) {//证明此时旋转的中心结点是root
  123.             root = child;
  124.             child.parent = null;
  125.             Node lchild = child.lchild;
  126.             child.lchild = center;
  127.             center.parent = child;
  128.             center.rchild = lchild;
  129.             if(lchild!=null) {
  130.                 lchild.parent = center;
  131.             }
  132.         } else {
  133.             if (MyBinarySearchTree.isRchild(center)) {//中心结点是父节点的右孩子
  134.                 parent.rchild = child;
  135.             } else {
  136.                 parent.lchild = child;
  137.             }
  138.             child.parent = parent;
  139.             Node lchild = child.lchild;//需要将旋转前child的右孩子放到旋转后center的左节点中
  140.             child.lchild = center;
  141.             center.parent = child;
  142.             center.rchild = lchild;
  143.             if(lchild!=null) {
  144.                 lchild.parent = center;
  145.             }
  146.         }
  147.     }
  148.  
  149.    
  150. }

各位大佬，原创不易呀，路过的点个赞！！！文章有错误欢迎大佬指正！！

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号