Java数据结构之平衡二叉树的原理与实现

目录
1 平衡二叉树的概述
2 平衡二叉树的实现原理
2.1 单旋转
2.2 双旋转
2.3 总结
3 平衡二叉树的构建
3.1 类架构
3.2 查找的方法
3.3 检查是否平衡的方法
3.4 插入的方法
3.5 查找最大值和最小值
3.6 删除的方法
4 平衡二叉树的总结
平衡二叉树(AVL树)，顾名思义，是一颗很“平衡”的树，它的平衡是相对于排序二叉树来说的。为了避免极端情况下二叉搜索树节点分布不均匀，甚至退化为链表，影响查找效率，我们引入了平衡二叉树，即让树的结构看起来尽量“均匀”，左右子树的节点数和层级尽量一样多。

本文详细介绍了平衡二叉树的概念和实现原理，并且提供了Java代码的完全实现。

1 平衡二叉树的概述
为了避免极端情况下二叉搜索树退化为链表，影响查找效率，我们引入了平衡二叉树，即让树的结构看起来尽量“均匀”，左右子树的节点数和层级尽量一样多。要想学习平衡二叉树并且掌握它，必须要先掌握二叉排序树，如果对二叉搜索树还不太明白的，包括为什么二叉排序树可能退化为链表，可以看看这篇文章：数据结构—二叉排序树的原理以及Java代码的完全实现。

平衡二叉树，又称AVL树，指的是左子树上的所有节点的值都比根节点的值小，而右子树上的所有节点的值都比根节点的值大，且左子树与右子树的高度差最大为1。因此，平衡二叉树满足所有二叉排序（搜索）树的性质，是在二叉排序树的基础上发展而来的。至于AVL，则是取自两个发明平衡二叉树的俄罗斯科学家的名字：G. M. Adelson-Velsky和E. M. Landis。

总的来说平衡二叉树具有如下性质：

它一定是一棵二叉排序树；
它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树，递归定义。
平衡因子BF（Balance Factor）： 我们将二叉树上节点的左子树深度减去右子树深度的值称为平衡因子，那么平衡二叉树上所有节点的平衡因子只可能是-1、0和1。只要二叉树上有一个节点的平衡因子的绝对值大于1，则该二叉树就是不平衡的。

上图中，图一是平衡二叉树，图二的59比58大，却是58的左子树，这是不符合二叉排序树的定义的，图二不是平衡二叉树。图3不是平衡二叉树的原因就在于，节点58的左子树高度为3，而右子树为空，二者差大于了绝对值1，因此它也不是平衡的。而经过适当的调整后的图4，它就符合了定义，因此它是平衡二叉树。

最小不平衡子树： 距离插入、删除节点最近的，且平衡因子的绝对值大于1的节点为根的子树，我们称为最小不平衡子树。下图中当新插入节点37时，距离它最近的平衡因子绝对值超过1的节点是58（即它的左子树高度3减去右子树高度1），所以从58开始以下的子树为最小不平衡子树。

2 平衡二叉树的实现原理
平衡二叉树实现原理的核心就是：由于在插入、删除节点以后，只有那些从插入点到根节点的路径上的节点的平衡可能被改变，因为只有这些节点的子树可能发生变化。因此，我们需要沿着这条路径上行到根并更新平衡信息，尝试找出最小不平衡树。在保持二叉排序树特性的前提下，调整最小不平衡子树中根节点和子结点之间的关系，进行相应的旋转（rotation），使之成为新的平衡子树。

先来看看插入的重平衡，因为到后面我们会发现插入和删除进行的重平衡操作基本是一致的。

我们把需要进行平衡（平衡因子绝对值大于1）的节点称为x，由于任意节点最多有两个儿子，因此出现高度不平衡就需要x点的两棵子树的高度差2，而这种不平衡只可能出现在下面四种情况中：

在节点X的左孩子节点的左子树中插入元素，简称LL
在节点X的左孩子节点的右子树中插入元素，简称LR
在节点X的右孩子节点的左子树中插入元素，简称RL
在节点X的右孩子节点的右子树中插入元素，简称RR
其中第1种情况和第4种情况是对称的，被称为发生“外边”的情况，可以通过单旋转来解决，而第2种情况和第3种情况是对称的，被称为发生在“内边”的情况，需要双旋转来解决。

案例：对数组中的元素{3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9}顺序插入并建立一个平衡二叉树。以这个案例为例，来讲解上面4个问题的通用解决办法和单旋转和双旋转的概念。

2.1 单旋转
首先是添加前两个元素“3、2”的时候，可以正常的构建平衡二叉树，到了第3个数“1”时，发现此时根节点“3”的平衡因子变成了2，此时整棵树都成了最小不平衡子树，因此需要调整结构。

上图中的情况情况符合条件1——LL，因此所采用单旋转来重平衡。此时，我们需要右旋（顺时针旋转）。旋转的目的实际上就是为了降低深度，保持平衡。

节点3经过右旋后，节点2变成了根节点，节点3变成了2的右子树，此时树节点1的深度降低了一级，整颗树重新回到了平衡。我们把通过一次旋转即可修复平衡的操作叫做单旋转。

平衡因子BF绝对值大于1的节点X称为失衡点，修复一棵被破坏的AVL树时，找到失衡点是很重要的，查找失衡点就是从新插入、删除的节点的位置向上回溯至根节点的过程。

然后我们再增加节点4，平衡因子没有超出限定范围。增加节点5时，节点3的BF值为-2，说明又要旋转了。

上图中的情况情况符合条件4——RR，需要采用单旋转来重平衡。此时，我们需要左旋（逆时针旋转）。

左旋之后，如上图右，树的深度降低了一级，此时整棵树又达到了平衡状态。继续，增加节点6时，发现根节点2的BF值变成了-2，所以我们对根节点进行了左旋。

左旋的结果使得节点2成为节点4的左孩子，原本处于2和4之间的节点3是4的左子树，由于旋转后需要满足二叉排序树特性，因此它成了节点2的右子树，因为该子树的每一个关键字都在2-4之间，因此这个变换是成立的。

现在我们来尝试总结出发生情况1和4时的通用解法。

首先，情况1和4可以提炼出一个通用模型：

模型中，左边如果要发生不平衡的情况1，那么左子树1的深度肯定比右子树1的深度深2层；右边如果要发生不平衡的情况4，那么左子树1的深度肯定比右子树1的深度浅2层。

针对上面情况1和情况4，我们分别使用右旋和左旋，来降低或者升高这两颗子树的深度：

如上图，情况1右旋之后，k2成为根节点，k1成为k2的右子节点，k2的右子树2成为k1的左子树；情况4左旋之后，k2成为根节点，k1成为k2的左子节点，k2的左子树2成为k1的右子树。树重新达到了平衡状态，这就是解决情况1和情况4的通解，并且我们可以发现它们是对称的。

下面增加节点7，这导致节点5的BF变成了-2，且符合情况4，需要左旋，根据上面的通解，采用下面的左旋方法让树重新成为平衡二叉树：

2.2 双旋转
上面的单旋转对于情况2和3是没有用的，因为此时树结构太深，单旋转并不会减低它的深度。此时需要使用双旋转。

当增加节点16时，结构无变化，再增加节点15，此时节点7的BF变成了-2。此时符合情况3：在节点X的右孩子节点的左子树中插入元素，简称RL。如下图：

此时简单的左旋无法解决问题：节点15成了16的右孩子，这是不符合二叉排序树的特性的，此时不能简单的左旋。如下图：

对于这种情况，我们对于关键节点7、16、15先建立一个更广泛的模型：

其中7-k1、16-k2、15-k3，并且节点7完全还可以拥有左子树，节点16可以拥有右子树，而节点15则可以拥有左右子树。

要想发生上面k1的BF为-2的情况，需要左子树2或右子树2其中一颗子树的深度比左子树1深两层，或者他们都是空子树，但是我们不知道是具体是什么情况，不过这没关系，在这里我们要求出一个对这个问题通解！

此时为了平衡高度，我们不能将k1当作根节点了，但是左旋——把k2当作根节点也不能解决问题（上面已经证实了），唯一的选择就是：将k3当作新的根节点，并且先使得k2右旋成为k3的右子树，然后k1左旋成为k3的左子树，并且左子树2成为k1的右子树，右子树2成为k2的左子树，这是完全成立的，这就是情况3的通解。 最终，右-左双旋结果如下：

我们可以看到，无论是具体发生了什么情况（左子树2或右子树2其中一颗子树的深度比左子树1深两层，或者他们都是空子树)，左-右双旋转换为上右图的形状之后，左子树2或右子树2都会被削减一层深度，而左子树1会被增加一层深度，这棵树始终都是一颗平衡二叉树。

实际上，右-左双旋，分开旋转的过程模型如下：

回到案例，案例中左子树2、右子树2、左子树1、右子树1都是空树，使用右-左双旋之后，树结构如下图，该树得以重新平衡：

接着插入14，情况与刚才类似，节点6的BF是-2，此时符合RL的情况（在节点6的右孩子节点15的左子树7中插入元素），如下图左，此时继续右-左双旋后，整棵树又回到了平衡状态，如下图右：

继续插入13，此时根节点4的BF变成了-2，符合情况4，此时使用一次单左旋即可解决问题：

继续插入12之后，向上回溯到节点14时，发现节点14的BF为2，此时符合情况1，需要右旋恢复平衡：

继续插入11之后，向上回溯到节点15时，发现节点15的BF为2，此时符合情况1，需要右旋恢复平衡：

继续插入10之后，向上回溯到节点12时，发现节点12的BF为2，此时符合情况1，需要右旋恢复平衡：

插入8之后，向上回溯到根节点也没有发现最小不平衡树，因此不需要旋转。最后插入9之后，我们发现出现了情况2，此时我们有情况1和情况4对称的经验，自然也知道需要右-左双旋的的对称操作——左-右双旋来重新平衡。

先来看左-右双旋模型：

它和右-左双旋模型就是对称操作，将k3当作新的根节点，并且先使得k2左旋成为k3的左子树，然后k1右旋成为k3的右子树，并且左子树2成为k2的右子树，右子树2成为k1的左子树，这是完全成立的，这就是情况2的通解。

左-右双旋之后，重新形成了平衡二叉树：

实际上，左-右双旋，分开旋转的过程模型如下：

节点添加完毕，最终形成了一颗平衡二叉树：

2.3 总结
插入节点的不平衡的情况只有四种：

在节点X的左孩子节点的左子树中插入元素，简称LL
在节点X的左孩子节点的右子树中插入元素，简称LR
在节点X的右孩子节点的左子树中插入元素，简称RL
在节点X的右孩子节点的右子树中插入元素，简称RR
其中1采用单右旋、4采用单左旋即可解决问题。2和3比较复杂，2需要采用左-右双旋、3需要采用右-左双旋。

1和4、2和3是对称的情况，现在综合起来看，所谓的旋转似乎也不那么复杂，并且我们已经求出了这几种问题的通解，该通解对于节点的删除是同样适用的，不必再考虑各种特殊情况，非常方便，下面来看看具体的代码实现！

3 平衡二叉树的构建
3.1 类架构
首先节点对象还是需要一个数据域和两个引用域，相比于二叉排序树，还要多一个节点高度的字段，这样方便计算平衡因子，并且提供返回节点高度的方法。 另外还需要一个比较器的引用，因为需要对元素进行排序，自然需要比较元素的大小，如果外部传递了比较器，那么就使用用户指定的比较器进行比较，否则，数据类型E必须是Comparable接口的子类，否则因为不能比较而报错。

另外，还需要提供中序遍历的方法，该遍历方法对于二叉排序树的结果将会顺序展示。
public class AvlTree<E> {
/**

  1.      * 外部保存根节点的引用
  2.      */
  3.     private BinaryTreeNode<E> root;
  5.     /**
  6.      * 自定义比较器
  7.      */
  8.     private Comparator<? super E> cmp;
  10.     /**
  11.      * 树节点的数量
  12.      */
  13.     private int size;
  15.     /**
  16.      * 内部节点对象
  17.      *
  18.      * @param <E> 数据类型
  19.      */
  20.     public static class BinaryTreeNode<E> {
  22.         //数据域
  23.         E data;
  24.         //左子节点
  25.         BinaryTreeNode<E> left;
  26.         //右子节点
  27.         BinaryTreeNode<E> right;
  28.         //节点高度 从0开始,从下往上;null节点高度返回-1
  29.         int height;
  31.         public BinaryTreeNode(E data) {
  32.             this.data = data;
  33.         }
  35.         @Override
  36.         public String toString() {
  37.             return data.toString();
  38.         }
  40.     }
  42.     /**
  43.      * 指定比较器
  44.      *
  45.      * @param cmp 比较器
  46.      */
  47.     public AvlTree(Comparator<? super E> cmp) {
  48.         this.cmp = cmp;
  49.     }
  51.     /**
  52.      * 空构造器
  53.      */
  54.     public AvlTree() {
  55.     }
  57.     /**
  58.      * 是否是空树
  59.      *
  60.      * @return true 是 ;false 否
  61.      */
  62.     public boolean isEmpty() {
  63.         return size == 0;
  64.     }
  66.     /**
  67.      * 返回节点数
  68.      *
  69.      * @return 节点数
  70.      */
  71.     public int size() {
  72.         return size;
  73.     }
  75.     /**
  76.      * 对元素进行比较大小的方法,如果传递了自定义比较器,则使用自定义比较器,否则则需要数据类型实现Comparable接口
  77.      *
  78.      * @param e1 被比较的第一个对象
  79.      * @param e2 被比较的第二个对象
  80.      * @return 0 相等 ;小于0 e1 < e2 ;大于0 e1 > e2
  81.      */
  82.     private int compare(E e1, E e2) {
  83.         if (cmp != null) {
  84.             return cmp.compare(e1, e2);
  85.         } else {
  86.             return ((Comparable<E>) e1).compareTo(e2);
  87.         }
  88.     }
  90.     /**
  91.      * 保存遍历出来的节点数据
  92.      */
  93.     List<BinaryTreeNode<E>> str = new ArrayList<>();
  95.     /**
  96.      * 中序遍历,提供给外部使用的api
  97.      *
  98.      * @return 遍历的数据
  99.      */
  100.     public String toInorderTraversalString() {
  102.         //如果是空树,直接返回空
  103.         if (isEmpty()) {
  104.             return null;
  105.         }
  106.         //从根节点开始递归
  107.         inorderTraversal(root);
  108.         //获取遍历结果
  109.         String s = str.toString();
  110.         str.clear();
  111.         return s;
  112.     }
  114.     /**
  115.      * 中序遍历 内部使用的递归遍历方法,借用了栈的结构
  116.      *
  117.      * @param root 节点,从根节点开始
  118.      */
  119.     private void inorderTraversal(BinaryTreeNode<E> root) {
  121.         BinaryTreeNode<E> left = getLeft(root);
  122.         if (left != null) {
  123.             //如果左子节点不为null,则继续递归遍历该左子节点
  124.             inorderTraversal(left);
  125.         }
  126.         //添加数据节点
  127.         str.add(root);
  128.         //获取节点的右子节点
  129.         BinaryTreeNode<E> right = getRight(root);
  130.         if (right != null) {
  131.             //如果右子节点不为null,则继续递归遍历该右子节点
  132.             inorderTraversal(right);
  133.         }
  134.     }
  136.     /**
  137.      * 获取左子节点
  138.      *
  139.      * @param parent 父节点引用
  140.      * @return 左子节点或者null--表示没有左子节点
  141.      */
  142.     public BinaryTreeNode<E> getLeft(BinaryTreeNode<E> parent) {
  143.         return parent == null ? null : parent.left;
  144.     }
  146.     /**
  147.      * 获取右子节点
  148.      *
  149.      * @param parent 父节点引用
  150.      * @return 右子节点或者null--表示没有右子节点
  151.      */
  152.     public BinaryTreeNode<E> getRight(BinaryTreeNode<E> parent) {
  153.         return parent == null ? null : parent.right;
  154.     }
  156.     /**
  157.      * 获取根节点
  158.      *
  159.      * @return 根节点 ;或者null--表示空树
  160.      */
  161.     public BinaryTreeNode<E> getRoot() {
  162.         return root;
  163.     }
  165.     /**
  166.      * 获取height
  167.      *
  168.      * @param node 节点
  169.      * @return 高度或者-1 表示节点为null
  170.      */
  171.     private int getHeight(BinaryTreeNode<E> node) {
  172.         return node == null ? -1 : node.height;
  173.     }

3.2 查找的方法
平衡二叉树就是一颗二叉排序树，其查找方法可以复用二叉排序树的查找方法，很简单：

若根节点的关键字值等于查找的关键字，成功，返回true；
否则，若小于根节点的关键字值，递归查左子树；
若大于根节点的关键字值，递归查右子树；
最终查找到叶子节点还是没有数据，那么查找失败，则返回false
/**

  1.      * 查找,开放给外部使用的api
  2.      * @param e 要查找的元素
  3.      * @return false 不存在 true 存在
  4.      */
  5.     public boolean contains(E e) {
  6.         return contains(e, root);
  7.     }
  9.     /**
  10.      * 查找,内部调用的方法,从根节点开始查找
  11.      *
  12.      * @param e    要查找的元素
  13.      * @param root 节点
  14.      * @return false 不存在 true 存在
  15.      */
  16.     private boolean contains(E e, BinaryTreeNode<E> root) {
  17.         /*null校验*/
  18.         if (root == null) {
  19.             return false;
  20.         }
  21.         /*调用比较的方法*/
  22.         int i = compare(e, root.data);
  23.         /*如果大于0，则说明e>root.date 继续查询右子树*/
  24.         if (i > 0) {
  25.             return contains(e, root.right);
  26.             /*如果小于0，则说明e<root.date 继续查询左子树*/
  27.         } else if (i < 0) {
  28.             return contains(e, root.left);
  29.         } else {
  30.             /*如果等于0，则说明e=root.date 即查询成功*/
  31.             return true;
  32.         }
  33.     }

3.3 检查是否平衡的方法
很简单，只需要递归的查看所有节点，判断是否存在的节点的左右子节点高度差绝对值是否大于1的情况就能判断了，如果存在，那么返回false表示不是平衡二叉树，不存在就返回true表示是平衡二叉树。
/**

  1.      * 保存是否平衡的标志
  2.      */
  3.     private boolean balance = true;
  5.     /**
  6.      * 检查是否是平衡二叉树的方法,当然也可以debug看,如果你不嫌麻烦……
  7.      *
  8.      * @return true 是 ；false 否
  9.      */
  10.     public boolean checkBalance() {
  11.         checkBalance(root);
  12.         boolean balanceNow=balance;
  13.         balance=true;
  14.         return balanceNow;
  15.     }
  17.     /**
  18.      * 递归检查是否平衡,实际上这里采用了后序遍历,即左子节点-右子节点-根节点的方法递归遍历检查
  19.      *
  20.      * @param root 根节点
  21.      * @return 节点的高度
  22.      */
  23.     private int checkBalance(BinaryTreeNode<E> root) {
  24.         if (root == null) {
  25.             return -1;
  26.         }
  27.         //返回左子树的高度
  28.         int hl = checkBalance(root.left);
  29.         //返回右子树的高度
  30.         int hr = checkBalance(root.right);
  31.         //如果root的左右子树高度差绝对值大于1,或者checkBalance和getHeight方法获取的左/右子树高度不一致,那么算作不平衡
  32.         if (Math.abs(getHeight(root.left) - getHeight(root.right)) > 1 ||
  33.                 getHeight(root.left) != hl || getHeight(root.right) != hr) {
  34.             balance = false;
  35.         }
  36.         return getHeight(root);
  37.     }

3.4 插入的方法
平衡二叉树和二叉排序树的最大区别就是在插入和删除的时候了。我们已经讨论过插入之后的4种出现平衡问题的特殊情况，这里不再赘述，下面看代码具体如何实现：
/**

  1.      * 插入,开放给外部使用的api
  2.      *
  3.      * @param e 要插入的元素
  4.      */
  5.     public void insert(E e) {
  6.         //返回root,但此时新的节点可能已经被插入进去了
  7.         root = insert(e, root);
  8.     }
  10.     /**
  11.      * 插入,开放给外部使用的api
  12.      *
  13.      * @param es 要插入的元素的数组,注意,数组元素的顺序存储的位置将会影响二叉排序树的生成
  14.      */
  15.     public void insert(E[] es) {
  16.         //返回root,但此时新的节点可能已经被插入进去了
  17.         for (E e : es) {
  18.             root = insert(e, root);
  19.         }
  21.     }
  23.     /**
  24.      * 插入,内部调用的方法,先从根节点开始递归查找要插入的位置,然后插入
  25.      * 大部分代码都和排序二叉树的相似，区别就是在插入之后，会调用尝试重平衡的方法rebalance
  26.      *
  27.      * @param e    要插入的数据
  28.      * @param root 节点
  29.      * @return 原节点重平衡之后的节点或者新插入的节点
  30.      */
  31.     private BinaryTreeNode<E> insert(E e, BinaryTreeNode<E> root) {
  32.         /*没有查找到,那么直接构建新的节点返回,将会在上一层方法中被赋值给其父节点的某个引用,这个插入的位置肯定是该遍历路径上的最后一点
  33.          * 即插入的元素节点肯定是属于叶子节点*/
  34.         if (root == null) {
  35.             size++;
  36.             return new BinaryTreeNode<>(e);
  37.         }
  38.         /*调用比较的方法*/
  39.         int i = compare(e, root.data);
  40.         /*如果大于0，则说明e>root.date 继续查询右子树*/
  41.         if (i > 0) {
  42.             //重新赋值
  43.             root.right = insert(e, root.right);
  44.             /*如果小于0，则说明e<root.date 继续查询左子树*/
  45.         } else if (i < 0) {
  46.             //重新赋值
  47.             root.left = insert(e, root.left);
  48.         } else {
  49.             /*如果等于0，则说明e=root.date 即存在节点 什么都不做*/
  50.         }
  51.         /*insert递归插入之后,在返回时,会调用重新平衡并且设置高度的方法 尝试重平衡root根节点  而不是像排序二叉树一样简单的返回root
  52.          *从新插入节点的父节点一直向上回溯直到根节点,尝试寻找最小不平衡树,找到之后会进行平衡,返回返回平衡之后的树,.*/
  53.         return rebalance(root);
  54.     }
  56.     /**
  57.      * 重平衡的方法
  58.      * 1)    在节点X的左孩子节点的左子树中插入元素，简称LL 右旋
  59.      * 2)    在节点X的左孩子节点的右子树中插入元素，简称LR 左-右双旋
  60.      * 3)    在节点X的右孩子节点的左子树中插入元素，简称RL 左旋
  61.      * 4)    在节点X的右孩子节点的右子树中插入元素，简称RR 右-左双旋
  62.      *
  63.      * @param root 树的根节点,无论是否是最小不平衡树,都是走这个方法
  64.      * @return 平衡之后的树的根节点
  65.      */
  66.     private BinaryTreeNode<E> rebalance(BinaryTreeNode<E> root) {
  67.         /*1、如果节点为null,直接返回null*/
  68.         if (root == null) {
  69.             return null;
  70.         }
  71.         /*2、开始旋转*/
  72.         /*2.1、如果左子树的高度减去右子树的高度值大于1,说明左子树的高度大于右子树的高度至少2层,可能是情况1、2 继续判断*/
  73.         if (getHeight(root.left) - getHeight(root.right) > 1) {
  74.             /*如果左子节点的左子节点高度大于左子节点的右子节点高度,那说明是情况1,否则是情况2*/
  75.             if (getHeight(root.left.left) >= getHeight(root.left.right)) {
  76.                 /*2.1.1、右旋*/
  77.                 root = rotateRight(root);
  78.             } else {
  79.                 /*2.1.2、左-右双旋*/
  80.                 root = rotateLeftAndRight(root);
  81.             }
  82.             /*2.2、如果右子树的高度减去左子树的高度值大于1,说明右子树的高度大于左子树的高度至少2层,可能是情况3、4 继续判断*/
  83.         } else if (getHeight(root.right) - getHeight(root.left) > 1) {
  84.             /*如果右子节点的右子节点高度大于右子节点的左子节点高度,那说明是情况4,否则是情况3*/
  85.             if (getHeight(root.right.right) >= getHeight(root.right.left)) {
  86.                 /*2.2.1、左旋*/
  87.                 root = rotateLeft(root);
  88.             } else {
  89.                 /*2.2.2、右-左双旋*/
  90.                 root = rotateRightAndLeft(root);
  91.             }
  92.         }
  93.         /*3、到这一步,说明旋转完毕,或者不需要旋转,但是都需要重新计算高度,高度为左/右子树高度最大值+1*/
  94.         root.height = Math.max(getHeight(root.left), getHeight(root.right)) + 1;
  95.         return root;
  96.     }
  98.     /**
  99.      * 右旋
  100.      * 通解:右旋之后，k2成为根节点，k1成为k2的右子节点，k2的右子树2成为k1的左子树
  101.      *
  102.      * @param k1 需要旋转的最小不平衡树根节点
  103.      * @return k2 旋转后的最小不平衡树根节点, 已经转换为平衡二叉树
  104.      */
  105.     private BinaryTreeNode<E> rotateRight(BinaryTreeNode<E> k1) {
  106.         //获取k2,k2是k1的左子节点
  107.         BinaryTreeNode<E> k2 = k1.left;
  108.         //k2的右子树成为k1的左子树
  109.         k1.left = k2.right;
  110.         //k1成为k2的右子节点
  111.         k2.right = k1;
  112.         //k1的高度等于k1的左或者右子树的高度的最大值+1;
  113.         k1.height = Math.max(getHeight(k1.left), getHeight(k1.right)) + 1;
  114.         //k2的高度等于k2的左子节点和k1的高度(此时k1就是k2的右子节点)的最大值+1
  115.         k2.height = Math.max(getHeight(k2.left), k1.height) + 1;
  116.         //返回k2,k2成为根节点
  117.         return k2;
  118.     }
  120.     /**
  121.      * 左旋 很简单,实际上就是右旋的镜像
  122.      * 通解:左旋之后，k2成为根节点，k1成为k2的左子节点，k2的左子树2成为k1的右子树
  123.      *
  124.      * @param k1 需要旋转的最小不平衡树根节点
  125.      * @return k2 旋转后的最小不平衡树根节点, 已经转换为平衡二叉树
  126.      */
  127.     private BinaryTreeNode<E> rotateLeft(BinaryTreeNode<E> k1) {
  128.         //获取k2,k2是k1的右子节点
  129.         BinaryTreeNode<E> k2 = k1.right;
  130.         //k2的左子树成为k1的右子树
  131.         k1.right = k2.left;
  132.         //k1成为k2的左子节点
  133.         k2.left = k1;
  134.         //k1的高度等于k1的左或者右子树的高度的最大值+1;
  135.         k1.height = Math.max(getHeight(k1.left), getHeight(k1.right)) + 1;
  136.         //k2的高度等于k2的右子节点和k1的高度(此时k1就是k2的左子节点)的最大值+1
  137.         k2.height = Math.max(getHeight(k2.right), k1.height) + 1;
  138.         //返回k2,k2成为根节点
  139.         return k2;
  140.     }
  142.     /**
  143.      * 右-左双旋
  144.      * 通解：将k3当作新的根节点，并且先使得k2右旋成为k3的右子树，然后k1左旋成为k3的左子树，并且左子树2成为k1的右子树，右子树2成为k2的左子树
  145.      *
  146.      * @param k1 需要旋转的最小不平衡树根节点
  147.      * @return 旋转后的最小不平衡树根节点, 已经转换为平衡二叉树
  148.      */
  149.     private BinaryTreeNode<E> rotateRightAndLeft(BinaryTreeNode<E> k1) {
  150.         /*1、先对k1的右子节点k2进行右旋,返回右旋之后的根节点k3,然后使得成为k3成为的k1的左子树*/
  151.         k1.right = rotateRight(k1.right);
  152.         /*2、然后对k1进行左旋,成为k3的左子树,返回的根节点就是k3,即返回旋转之后的根节点*/
  153.         return rotateLeft(k1);
  154.     }
  156.     /**
  157.      * 左-右双旋 很简单,实际上就是右-左双旋的镜像
  158.      * 通解: 将k3当作新的根节点，并且先使得k2左旋成为k3的左子树，然后k1右旋成为k3的右子树，并且左子树2成为k2的右子树，右子树2成为k1的左子树
  159.      *
  160.      * @param k1 需要旋转的最小不平衡树根节点
  161.      * @return 旋转后的最小不平衡树根节点, 已经转换为平衡二叉树
  162.      */
  163.     private BinaryTreeNode<E> rotateLeftAndRight(BinaryTreeNode<E> k1) {
  164.         /*1、先对k1的左子节点k2进行左旋,返回左旋之后的根节点k3,然后使得成为k3成为的k1的左子树*/
  165.         k1.left = rotateLeft(k1.left);
  166.         /*2、然后对k1进行右旋,成为k3的右子树,返回的根节点就是k3,即返回旋转之后的根节点*/
  167.         return rotateRight(k1);
  168.     }

3.4.1 测试
AvlTree<Integer> avlTree = new AvlTree<>();
Integer[] es = new Integer[]{3, 2, 1, 4, 5, 6, 7, 16, 15, 14, 13, 12, 11, 10, 8, 9};
//批量插入
avlTree.insert(es);
//中序遍历输出
System.out.println(avlTree.toInorderTraversalString());
//检查是否平衡
System.out.println(avlTree.checkBalance());
//数量
System.out.println(avlTree.size());
在insert之后打上断点，Debug，可以看到avlTree的数据结构和在实现原理中最终的结构是一致的。

3.5 查找最大值和最小值
很简单，最左边的节点一定是最小的，最右边的节点一定是最大的。因此查找最小的节点只需要向左递归查找，查找最大的节点只需要向右递归查找
/**

  1.  * 查找最小的节点
  2.  *
  3.  * @param root 根节点
  4.  * @return 最小的节点
  5.  */
  6. private BinaryTreeNode<E> findMin(BinaryTreeNode<E> root) {
  7.     if (root == null) {
  8.         return null;
  9.         /*如果该节点没有左右子节点，那么该节点就是最小的节点，返回*/
  10.     } else if (root.left == null) {
  11.         return root;
  12.     }
  13.     /*如果该节点存在左子节点，那么继续向左递归查找*/
  14.     return findMin(root.left);
  15. }
  17. /**
  18.  * 查找最大的节点
  19.  *
  20.  * @param root 根节点
  21.  * @return 最大的节点
  22.  */
  23. private BinaryTreeNode<E> findMax(BinaryTreeNode<E> root) {
  24.     if (root == null) {
  25.         return null;
  26.         /*如果该节点没有右子节点，那么该节点就是最大的节点，返回*/
  27.     } else if (root.right == null) {
  28.         return root;
  29.     }
  30.     /*如果该节点存在右子节点，那么继续向右递归查找*/
  31.     return findMax(root.right);
  32. }

3.6 删除的方法
平衡二叉树节点的删除同样可能导致产生不平衡的状态，因此同样在二叉排序树的删除代码的基础上，删除元素之后需要在删除节点之上进行回溯直到根节点，尝试找出最小不平衡树来进行重平衡。其平衡的方法是和插入的时候是一样的。
/**

  1.  * 删除,开放给外部使用的api
  2.  *
  3.  * @param e 要删除的元素
  4.  */
  5. public void delete(E e) {
  6.     //返回root,但此时可能有一个节点已经被删除了
  7.     root = delete(e, root);
  8. }
  10. /**
  11.  * 删除,内部调用的方法,删除分为三种情况: 1、该节点没有子节点 2、该字节仅有一个子节点 3、该节点具有两个子节点
  12.  *
  13.  * @param e    要删除的数据
  14.  * @param root (子)树根节点
  15.  * @return 该根节点重平衡之后的节点
  16.  */
  17. private BinaryTreeNode<E> delete(E e, BinaryTreeNode<E> root) {
  18.     /*没有查找到,那么什么都不做*/
  19.     if (root == null) {
  20.         return null;
  21.     }
  22.     /*调用比较的方法*/
  23.     int i = compare(e, root.data);
  24.     /*如果大于0，则说明e>root.date 继续查询右子树*/
  25.     if (i > 0) {
  26.         //重新赋值
  27.         root.right = delete(e, root.right);
  28.         /*如果小于0，则说明e<root.date 继续查询左子树*/
  29.     } else if (i < 0) {
  30.         //重新赋值
  31.         root.left = delete(e, root.left);
  32.     } else {
  33.         /*如果等于0，则说明e=root.date 即查询成功 开始执行删除*/
  34.         /*如果两个子节点都不为null*/
  35.         if (root.left != null && root.right != null) {
  36.             /*递归查找最小的节点，然后递归删除*/
  37.             root.data = findMin(root.right).data;
  38.             root.right = delete(root.data, root.right);
  39.         } else {
  40.             /*如果一个子节点不为null，则返回该子节点；或者两个子节点都为null，则返回null
  41.              * 此时该root节点已经被"绕过了"*/
  42.             root = (root.left != null) ? root.left : root.right;
  43.             --size;
  44.         }
  45.     }
  46.     /*和二叉排序树直接返回节点不同的是,删除操作完成之后将会调用该方法,从被删除节点回溯至根节点,对节点进行重平衡,然后才返回平衡后的节点*/
  47.     return rebalance(root);
  48. }

3.6.1 测试

针对上面插入的平衡二叉树进行删除：
System.out.println(“======>首先删除5 此时没有影响,不需要重平衡”);
avlTree.delete(5);
//检查是否平衡
System.out.println(avlTree.checkBalance());
//中序遍历输出
System.out.println(avlTree.toInorderTraversalString());

  1. System.out.println("======>再次删除6  此时节点4的BF为2 需要右旋重平衡");
  2. avlTree.delete(6);
  3. //检查是否平衡
  4. System.out.println(avlTree.checkBalance());
  5. //中序遍历输出
  6. System.out.println(avlTree.toInorderTraversalString());
  8. System.out.println("======>再次删除11  由于该节点拥有左右子树,实际上删除的是该节点的右子树的最小节点12,然后将12的值赋值给11的节点,并导致节点12的原父节点11不平衡,需要重平衡");
  9. avlTree.delete(11);
  10. //检查是否平衡
  11. System.out.println(avlTree.checkBalance());
  12. //中序遍历输出
  13. System.out.println(avlTree.toInorderTraversalString());
  15. System.out.println("======>再次删除7  由于该节点拥有左右子树,实际上删除的是该节点的右子树的最小节点8,然后将8的值赋值给7的节点,并导致节点8的原父节点9不平衡,需要重平衡");
  16. avlTree.delete(7);
  17. //检查是否平衡
  18. System.out.println(avlTree.checkBalance());
  19. //中序遍历输出
  20. System.out.println(avlTree.toInorderTraversalString());
  22. System.out.println("======>再次删除9、12  此时不需要重平衡");
  23. avlTree.delete(9);
  24. avlTree.delete(12);
  25. //检查是否平衡
  26. System.out.println(avlTree.checkBalance());
  27. //中序遍历输出
  28. System.out.println(avlTree.toInorderTraversalString());
  30. System.out.println("======>最后删除8  由于该节点拥有左右子树,实际上删除的是该节点的右子树的最小节点10节点,然后将10的值赋值给8的节点,并导致节点10的原父节点13不平衡,需要重平衡");
  31. avlTree.delete(8);
  32. //检查是否平衡
  33. System.out.println(avlTree.checkBalance());
  34. //中序遍历输出
  35. System.out.println(avlTree.size());
  36. System.out.println(avlTree.toInorderTraversalString());

在进行上面的一系列删除之后，树结构会变成如下形状：

4 平衡二叉树的总结
平衡二叉树是基于二叉排序树的，但是由于其必须保持平衡的特性，因此其编码难度比二叉排序树的编码难度更高，不过如果我们搞懂了其旋转的原理，那么实现起来还是比较简单的。

如果我们需要查找的集合本身没有顺序，在频繁查找的同时也需要经常的插入和删除操作，显然我们需要构建一棵二叉排序树，但是不平衡的二叉排序树，极端情况下可能退化为链表，查找效率是非常低的，因此我们需要在构建时，就让这棵二叉排序树是动态的转换为平衡二叉树，此时我们的查找时间复杂度就为O(logn)，而插入和删除也为O(logn)。这显然是比较理想的一种动态查找表算法。

本文介绍了平衡二叉树的原理以及Java代码的完全实现，要想搞懂平衡二叉树需要先搞懂二叉排序树：二叉排序树的详解以及Java代码的完全实现。而搞懂平衡二叉树又是搞懂红黑树的基础，后续文章我们将会介绍红黑树的概念以及Java代码的完全实现！

更多相关文章

  1. Android(安卓)采用Pull解析XML内容 【学习记录】
  2. Android中json操作数据的使用
  3. 做电商/外贸，搭建一个自己的网站要怎么选服务器（配置）？
  4. Android(安卓)输入事件一撸到底之源头活水（1）
  5. Android(安卓)打造任意层级树形控件 考验你的数据结构和设计
  6. Android连载之：第三章第二节：Android用户界面
  7. Zookeeper一致性协议Zab详解
  8. kubernetes-ingress 安装
  9. Android(安卓)事件全局监听（二）需要root权限 ，使用getevent监听Andr

随机推荐

  1. c语言函数如何声明
  2. 程序中的注释部分是否参加编译?
  3. c语言％4d什么意思
  4. c语言文件的扩展名是什么
  5. c语言的四大数据类型是什么？
  6. ASP.NET数据库密码：MD5加密算法详解
  7. net4.0怎么安装
  8. unity3d用什么语言开发？
  9. ASP.NET图形验证码生成实践
  10. 用c程序实现的算法必须要有输入个输出操