【算法】论平衡二叉树（AVL）的正确种植方法

时间 2019-12-05

标签算法平衡二叉树 avl 正确种植方法栏目应用数学繁體版

原文原文链接

参考资料

《算法（java）》 — — Robert Sedgewick， Kevin Wayne

《数据结构》 — — 严蔚敏

2017年度原创IT博客评选：http://www.itbang.me/goVote/203

引子

近日，为了响应市政府“全市绿化”的号召，身为共青团员的我决定在家里的后院挖坑种二叉树，以支援政府实现节能减排的伟大目标，并进一步为实现共同富裕和民族复兴打下坚实的基础....

咳咳，很差意思，扯远了。额，就是我上次不是种二叉查找树嘛（见上面的连接），发现大多数二叉树都长的比较好，但总有那么那么几颗长势很不如人意，我对此感到很疑惑（你们思考一下这是为何）

直到—— 看门的李大爷给我送过来了一包树种，神秘兮兮地跟我说这是能自动吸取氮磷钾，犹如金坷垃般神奇的树种，它叫 —— “平衡二叉树”

正文开始

平衡二叉树的由来

普通二叉搜索树的缺陷

普通二叉搜索树的动态方法多是“有缺陷”的，或者说：可能会带来不良的反作用

普通二叉搜索树的API分为两种： 静态方法和动态方法。

静态方法不会对二叉树作修改，而仅仅是获取相关的信息，例如：

get(根据key获取val)
max(获取最大key),
min(获取最小key)
floor（对key向下取整）
ceiling(对key向上取整)
rank（获取给定key的排名）
select（根据排名得到给定key）

而动态方法则会修改树中结点，并进一步影响二叉树的结构

put (插入键值对)
delete(删除键值对)

BST的动态方法可能会修改二叉树的结构，使其结点分布不均匀，使得在下一步的操做中，静态方法和动态方法都变得更为低效。html

插入的顺序影响二叉搜索树的构造

一样的数据集合，插入二叉搜素树中的顺序的不一样，树的形状和结构也是不一样的

以put方法为例，咱们重复调用它，用key为1, 2, 3, 4的结点构造一颗二叉搜索树。那么这颗二叉搜索树的形状取决于不一样的key的插入顺序

可能在你眼里，构造的树多是比较“均匀”的。但让咱们看看， 若是按照彻底正序或者逆序输入，二叉搜索树的形状就会走向一个很差的极端：

若是按照 1 -> 2 -> 3 -> 4 的顺序插入，那么这颗二叉树在形状上会变得像一颗单链表！

一样，若是按照4 -> 3 -> 2 ->1 的顺序插入，它在形状上会变成一颗向左倾斜的链表

为何二叉搜索树会变得低效？

二叉搜索树查找的原理和二分查找相似，就是借助于它自己的结构，在遍历查找的过程当中跳过一些没必要要的结点的比较，从而实现高效的查找。 BST的其余API也是借助了这一优点实现性能的飞跃。可是，在这种状况下，查找一个结点将要像链表同样遍历它通过的全部结点， 二叉搜索树的高效之源已经丧失了。这就是最坏的状况。

插入和删除操做均可能下降将来操做的性能

上面我只讲述了插入操做对二叉树形状和操做性能的影响，但让咱们反向思考一下就会发现，删除操做的效果也有相似之处：可能使得原来分布得比较均匀的结点，在删除部分结点以后，总体的分布变得不均匀了，并影响到将来操做的性能。

这里我先先入为主地灌输一个关于“平衡”的概念： “二叉搜索树各结点分布均匀、各类操做都较为高效的状态”

什么是平衡二叉树

综上所述，咱们但愿在进行动态操做（插入和删除）以后，可以经过一些指标，对二叉树的形状变化进行监督，当发现树的形状开始变得不平衡的时候，当即修正二叉树的形状。

经过这种方式， 不断地使得二叉树的形状和构造维持着一个“平衡”的状态，添加了这种维护机制的二叉搜索树，就是平衡二叉树

上个图，对比一下普通的二叉搜索树和平衡二叉树的区别：

普通的二叉搜索树（BST）

平衡二叉树（AVL）

这还不够？再来个动图看一看！

（图中key的大小关系：按字母排序，A最小，Z最大）

这里咱们能够很明显地看到平衡二叉树的优点所在： 使得查找的平均深度下降，优化各个API的性能开销

AVL和普通BST区别在于动态方法java

平衡二叉树和普通二叉查找树区别主要在于动态方法！(put,delete) 。它们的静态方法基本是相同的！（get,min,max,floor,ceiling, rank,select）

因此本文编写的主要API就只有两个: put和delete

平衡二叉树的监督机制

咱们前面提到了平衡二叉树有它的监督机制，既然说到“监督”，那必然就有一个用于判断当前二叉树平不平衡的指标，这个监督的指标，就是平衡因子（Balance Factor）。

在二叉树中，咱们为每一个结点定义了平衡因子这个属性。

平衡因子： 某个结点的左子树的高度减去右子树的高度获得的差值。

平衡二叉树（AVL）：全部结点的平衡因子的绝对值都不超过1。即对平衡二叉树每一个结点来讲，其左子树的高度 - 右子树高度获得的差值只能为 1， 0 ， -1 这三个值。取得小于 -1或者大于1的值，都被视为打破了二叉树的平衡

图解平衡因子

下图中：

对根结点A而言，它左子树高度为2，右子树高度为1，那么它的平衡因子BF = 2 - 1 = 1

对结点B而言，它左子树高度为1，没有右子树（高度视为0），BF = 1 - 0 = 1；

图解平衡二叉树

以下图所示，图a的两颗是平衡二叉树，图b的两颗则是非平衡二叉树

因此，只有全部结点都符合“平衡因子的绝对值都不超过1” 这一条件的二叉树，才是平衡二叉树；

若是有一个结点不符合条件，那么这颗二叉树就不是平衡二叉树。

上面咱们说到，在动态操做（插入/删除）的过程当中，咱们须要平衡因子做为“指标”，去监督当前这颗二叉树的构造是否符合预期，即——是不是一颗平衡二叉树。

而平衡因子BF的计算须要用到该节点的孩子结点的高度属性，这也就意味着，咱们要从Node类的实例变量入手，为每一个结点设置height属性，并在二叉树结构发生变化时，更新并维护height的正确性。

为每一个结点设置并维护height属性

height属性的设置

啊，终于能够开始写代码了。以下，咱们在Node类中写入了实例变量height,并初始化为1

/**
 * @Author: HuWan Peng
 * @Date Created in 10:35 2017/12/29
 */
public class AVL {
  Node root; // 根结点
  private class Node {
    int key,val;
    Node left,right;
    int height = 1; // 每一个结点的高度属性
    public Node (int key, int val) {
      this.key = key;
      this.val = val;
    }
  }
  // 编写API方法
}

height属性的维护和更新

让咱们思考一下， 结点height属性在何时会发生变化： 固然是在二叉树结构发生变化的时候，具体表现为：

在插入结点时（put），沿插入的路径更新结点的高度值（不必定会加1 ！只是要从新计算）
在删除结点时（delete）,沿删除的路径更新结点的高度值（不必定减1！只是要从新计算）
在发现二叉树变得不平衡的时候，经过“旋转”使其平衡，这时候要更新相关结点的高度值（具体的我下面会详细讲）

下面的代码是更新结点高度的示范例子：

  /**
   * @description: 返回两个数中的最大值
   */
  private int max (int a, int b) {
    return a>b ? a : b;
  }
 
  /**
   * @description: 得到当前结点的高度
   */
  private int height (Node x) {
    if(x == null) return 0;
    return x.height;
  }
 
  // 下面的insert方法是简化后的代码
  public Node insert (Node x, int key, int val) {
    其余代码 。。。。
    insert(x.left, key, val); // 进行递归的插入
    x.height = max(height(x.left),height(x.right)) + 1; // 更新结点的height属性（沿着递归路径）
    return x;
  }

最关键的是

  x.height = max(height(x.left),height(x.right)) + 1;

这一句代码，由于在递归的插入或删除以后，沿着递归路径上方的结点的height都有可能会改变， 因此要经过依次调用这一段代码，沿着递归路径自下而上地更新沿途结点的height属性值。

计算BF以监督平衡二叉树的状态

只要咱们能正确地维护每一个结点的height，咱们就能对动态操做中受影响的结点，准确计算其平衡因子（BF），从而判断当前的平衡二叉树的状态

计算某个结点平衡因子的方法：

  /**
   * @description: 得到平衡因子
   */
  private int getBalance (Node x) {
    if(x == null) return 0;
    return height(x.left) - height(x.right);
  }

平衡二叉树的修正机制

当咱们计算出某个结点的平衡因子的绝对值超过1时，咱们就要对其进行修正，即经过平衡化的处理，使得不平衡的二叉树从新变得平衡。

左旋和右旋

二叉树的平衡化有两大基础操做：左旋和右旋

1. 左旋，便是逆时针旋转；右旋，便是顺时针旋转

2. 这种旋转在整个平衡化过程当中可能进行一次或屡次

3.且是从失去平衡的最小子树根结点开始的(即离插入结点最近的、平衡因子超过1的祖先结点)

右旋操做

右旋操做过程：使结点3位置“下沉”，而结点2位置“上浮”，反转当前结点和它左儿子的父子关系。

可是，让咱们思考地再全面一些：若是上图中的结点2有右儿子的话，状况会变得怎样？

这时候结点2将保持有3条连接，若是在这种状况下旋转，结点二须要抛弃一条连接。

咱们的处理方式是： 抛弃结点2的右儿子，将其和旋转后的结点3链接，成为结点3的左儿子

我将上面的这种假设的结点戏称为“拖油瓶”结点， 以下图中的黄色结点

紧接上图，咱们须要先断开4结点和3结点间的连接，而后把它转接到旋转后的结点5上：

固然，有的时候咱们假设的这个“拖油瓶”结点（黄色结点）多是空的，可是这并不影响咱们的编码。

好嘞！让咱们来编写右旋的代码：

  /**
   * @description: 右旋方法
   */
  private Node rotateRight (Node x) {
    Node y = x.left; // 取得x的左儿子
    x.left = y.right; // 将x左儿子的右儿子（"拖油瓶"结点）连接到旋转后的x的左连接中
    y.right = x; // 调转x和它左儿子的父子关系，使x成为它原左儿子的右子树
    x.height = max(height(x.left),height(x.right)) + 1; // 更新并维护受影响结点的height
    y.height = max(height(y.left),height(y.right)) + 1; // 更新并维护受影响结点的height
    return y; // 将y返回
  }

左旋操做

左旋操做的过程和右旋同样：

例以下面：

1. 结点2位置“下沉”，而结点4位置上浮，反转当前结点和它右儿子的父子关系（2和4），使2结点变成4结点的左儿子。

2. 同时断裂结点3和结点4间的连接，转接到结点2中（处理拖油瓶结点）

左旋方法代码以下：

  /**
   * @description: 左旋方法
   */
  private  Node rotateLeft (Node x) {
    Node y = x.right;  // 取得x的右儿子
    x.right = y.left; // 将x右儿子的左儿子（"拖油瓶"结点）连接到旋转后的x的右连接中
    y.left = x; // 调转x和它右儿子的父子关系，使x成为它原右儿子的左子树
    x.height = max(height(x.left),height(x.right)) + 1; // 更新并维护受影响结点的height
    y.height = max(height(y.left),height(y.right)) + 1; // 更新并维护受影响结点的height
    return y; // 将y返回
  }

平衡化操做的四种状况

以左旋操做和右旋操做为基础，构成了平衡化操做的四种状况

假设因为在二叉排序树上插入结点而失去平衡的最小子树的根结点为a (即a是离插入结点最近的、平衡因子超过1的祖先结点)，则失去平衡后的调整操做分为如下4种状况:

1. 单次右旋： 因为在a的左子树的根结点的左子树上插入结点（LL），使a的平衡因子由1变成2，致使以a为根的子树失去平衡，则需进行一次的向右的顺时针旋转操做

2. 单次左旋： 因为在a的右子树根结点的右子树上插入结点（RR），a的平衡因子由-1变成-2，致使以a为根结点的子树失去平衡，则须要进行一次向左的逆时针旋转操做

3. 两次旋转、先左旋后右旋： 因为在a的左子树根结点的右子树上插入结点（LR），致使a的平衡因子由1变成2，致使以a为根结点的子树失去平衡，须要进行两次旋转，先左旋后右旋

4.两次旋转，先右旋后左旋： 因为在a的右子树根结点的左子树上插入结点（RL）， a的平衡因子由-1变成-2，致使以a为根结点的子树失去平衡，则须要进行两次旋转，先右旋后左旋

那么问题来了，怎么分别判断LL， RR，LR，RL这四种破环平衡的场景呢？

咱们能够根据当前破坏平衡的结点的平衡因子，以及其孩子结点的平衡因子来判断，具体以下图所示：

（BF表示平衡因子，最下方的那个结点是新插入的结点）

编写平衡化代码

有了以上的知识基础，让咱们来编写下咱们的平衡化代码

  /**
   * @description: 得到平衡因子
   */
  private int getBalance (Node x) {
    if(x == null) return 0;
    return height(x.left) - height(x.right);
  }
  /**
   * @description: 平衡化操做：  检测当前结点是否失衡，若失衡则进行平衡化
   */
  private Node reBalance (Node x) {
    int balanceFactor = getBalance(x);
    if(balanceFactor > 1&&getBalance(x.left)>0) { // LL型，进行单次右旋
     return rotateRight(x);
    }
    if(balanceFactor > 1&&getBalance(x.left)<=0) { //LR型 先左旋再右旋
      Node t = rotateLeft(x);
      return rotateRight(t);
    }
    if(balanceFactor < -1&&getBalance(x.right)<=0) {//RR型， 进行单次左旋
      return rotateLeft(x);
    }
    if(balanceFactor < -1&&getBalance(x.right)>0) {// RL型，先右旋再左旋
      Node t = rotateRight(x);
      return rotateLeft(t);
    }
    return x;
  }

AVL类的API编码

下面我将展现平衡二叉树的put方法和delete方法的代码，而这两个方法绝大部分的代码仍是基于二叉查找树的put方法和delete方法的，因此还不太了解BST的同窗能够看一看我上篇文章对BSTput方法和delete方法的解析：

【算法】二叉查找树（BST）实现字典API

插入方法

在看代码前能够先看下对二叉查找树中put方法的解析

二叉查找树的put方法

平衡查找树的put方法

  /**
   * @description: 插入结点（键值对）
   */
  public Node put (Node x, int key, int val) {
    if(x == null) return new Node(key, val); // 插入键值对
    if     (key<x.key) x.left  = put(x.left, key, val); // 向左子树递归插入
    else if(key>x.key) x.right = put(x.right,key, val); // 向右子树递归插入
    else x.val = val; // key已存在， 替换val
    x.height = max(height(x.left),height(x.right)) + 1; // 沿递归路径从下至上更新结点height属性
    x = reBalance(x); // 沿递归路径从下往上, 检测当前结点是否失衡，若失衡则进行平衡化
    return x;
  }

删除方法

删除方法比较复杂，在看代码前能够先看下对二叉查找树中put方法的解析

二叉查找树的delete方法

平衡查找树的delete方法

  /**
   * @description: 返回最小键
   */
  private Node min (Node x) {
    if(x.left == null) return x; // 若是左儿子为空，则当前结点键为最小值，返回
    return min(x.left);  // 若是左儿子不为空，则继续向左递归
  }
  public int min () {
    if(root == null) return -1;
    return min(root).key;
  }
 
  /**
   * @description: 删除最小键的结点
   */
  public Node deleteMin (Node x) {
    if(x.left==null) return x.right; // 若是当前结点左儿子空，则将右儿子返回给上一层递归的x.left
    x.left = deleteMin(x.left);// 向左子树递归， 同时重置搜索路径上每一个父结点指向左儿子的连接
    return x; // 当前结点不是min
  }
  public void deleteMin () {
    root = deleteMin(root);
  }
 
  /**
   * @description: 删除给定key的键值对
   */
  private Node delete (int key,Node x) {
    if(x == null) return null;
    if      (key<x.key) x.left  = delete(key,x.left); // 向左子树查找键为key的结点
    else if (key>x.key) x.right = delete(key,x.right); // 向右子树查找键为key的结点
    else{
      // 结点已经被找到，就是当前的x
      if(x.left==null) return x.right; // 若是左子树为空，则将右子树赋给父节点的连接
      if(x.right==null) return x.left; // 若是右子树为空，则将左子树赋给父节点的连接
      Node inherit = min(x.right); // 取得结点x的继承结点
      inherit.right = deleteMin(x.right); // 将继承结点从原来位置删除，并重置继承结点右连接
      inherit.left = x.left; // 重置继承结点左连接
      x = inherit; // 将x替换为继承结点
    }
    if(root == null) return root;
    x.height = max(height(x.left),height(x.right)) + 1; // 沿递归路径从下至上更新结点height属性
    x = reBalance(x); // 沿递归路径从下往上, 检测当前结点是否失衡，若失衡则进行平衡化
    return x;
  }
  public void delete (int key) {
    root = delete(key, root);
  }

测试AVL和BST的动态操做对二叉树结构的影响

下面咱们用层序遍历的方式进行测试：

  /**
   * @description: 二叉树层序遍历
   */
  private void levelIterator () {
    LinkedList <Node> queue = new LinkedList <Node>();
    Node current = null;
    int childSize = 0;
    int parentSize = 1;
    queue.offer(root);
    while(!queue.isEmpty()) {
      current = queue.poll();//出队队头元素并访问
      System.out.print(current.val +" ");
      if(current.left != null)//若是当前节点的左节点不为空入队
      {
        queue.offer(current.left);
        childSize++;
      }
      if(current.right != null)//若是当前节点的右节点不为空，把右节点入队
      {
        queue.offer(current.right);
        childSize++;
      }
      parentSize--;
      if (parentSize == 0)
      {
        parentSize = childSize;
        childSize = 0;
        System.out.println("");
      }
    }
  }

测试普通BST

  public static void main(String [] args) {
    BST bst = new BST();
    bst.put(1,11);
    bst.put(2,22);
    bst.put(3,33);
    bst.put(4,44);
    bst.put(5,55);
    bst.put(6,66);
    bst.levelIterator();
  }

输出：

(6层！！！)

测试AVL：

  public static void main (String [] args) {
    AVL avl = new AVL();
    avl.put(1,11);
    avl.put(2,22);
    avl.put(3,33);
    avl.put(4,44);
    avl.put(5,55);
    avl.put(6,66);
    avl.levelIterator();
  }

输出：

(只有3层！)

44
22 55
11 33 66

所有代码

import java.util.LinkedList;
 
/**
* @Author: HuWan Peng
* @Date Created in 10:35 2017/12/29
*/
public class AVL {
  Node root; // 根结点
  private class Node {
    int key,val;
    Node left,right;
    int height = 1; // 每一个结点的高度属性
    public Node (int key, int val) {
      this.key = key;
      this.val = val;
    }
  }
  /**
   * @description: 返回两个数中的最大值
   */
  private int max (int a, int b) {
    return a>b ? a : b;
  }
 
  /**
   * @description: 得到当前结点的高度
   */
  private int height (Node x) {
    if(x == null) return 0;
    return x.height;
  }
  /**
   * @description: 得到平衡因子
   */
  private int getBalance (Node x) {
    if(x == null) return 0;
    return height(x.left) - height(x.right);
  }
 
  /**
   * @description: 右旋方法
   */
  private Node rotateRight (Node x) {
    Node y = x.left; // 取得x的左儿子
    x.left = y.right; // 将x左儿子的右儿子（"拖油瓶"结点）连接到旋转后的x的左连接中
    y.right = x; // 调转x和它左儿子的父子关系，使x成为它原左儿子的右子树
    x.height = max(height(x.left),height(x.right)) + 1; // 更新并维护受影响结点
    y.height = max(height(y.left),height(y.right)) + 1; // 更新并维护受影响结点
    return y; // 将y返回
  }
 
  /**
   * @description: 左旋方法
   */
  private  Node rotateLeft (Node x) {
    Node y = x.right;  // 取得x的右儿子
    x.right = y.left; // 将x右儿子的左儿子（"拖油瓶"结点）连接到旋转后的x的右连接中
    y.left = x; // 调转x和它右儿子的父子关系，使x成为它原右儿子的左子树
    x.height = max(height(x.left),height(x.right)) + 1; // 更新并维护受影响结点
    y.height = max(height(y.left),height(y.right)) + 1; // 更新并维护受影响结点
    return y; // 将y返回
  }
 
  /**
   * @description: 平衡化操做
   */
  private Node reBalance (Node x) {
    int balanceFactor = getBalance(x);
    if(balanceFactor > 1&&getBalance(x.left)>0) { // LL型，进行单次右旋
     return rotateRight(x);
    }
    if(balanceFactor > 1&&getBalance(x.left)<=0) { //LR型 先左旋再右旋
      Node t = rotateLeft(x);
      return rotateRight(t);
    }
    if(balanceFactor < -1&&getBalance(x.right)<=0) {//RR型， 进行单次左旋
      return rotateLeft(x);
    }
    if(balanceFactor < -1&&getBalance(x.right)>0) {// RL型，先右旋再左旋
      Node t = rotateRight(x);
      return rotateLeft(t);
    }
    return x;
  }
  /**
   * @description: 插入结点（键值对）
   */
  public Node put (Node x, int key, int val) {
    if(x == null) return new Node(key, val); // 插入键值对
    if     (key<x.key) x.left  = put(x.left, key, val); // 向左子树递归插入
    else if(key>x.key) x.right = put(x.right,key, val); // 向右子树递归插入
    else x.val = val; // key已存在， 替换val
    x.height = max(height(x.left),height(x.right)) + 1; // 沿递归路径从下至上更新结点height属性
    x = reBalance(x); // 沿递归路径从下往上, 检测当前结点是否失衡，若失衡则进行平衡化
    return x;
  }
 
  public void put (int key,int val) {
    root = put(root,key,val);
  }
 
  /**
   * @description: 返回最小键
   */
  private Node min (Node x) {
    if(x.left == null) return x; // 若是左儿子为空，则当前结点键为最小值，返回
    return min(x.left);  // 若是左儿子不为空，则继续向左递归
  }
  public int min () {
    if(root == null) return -1;
    return min(root).key;
  }
 
  /**
   * @description: 删除最小键的结点
   */
  public Node deleteMin (Node x) {
    if(x.left==null) return x.right; // 若是当前结点左儿子空，则将右儿子返回给上一层递归的x.left
    x.left = deleteMin(x.left);// 向左子树递归， 同时重置搜索路径上每一个父结点指向左儿子的连接
    return x; // 当前结点不是min
  }
  public void deleteMin () {
    root = deleteMin(root);
  }
 
  /**
   * @description: 删除给定key的键值对
   */
  private Node delete (int key,Node x) {
    if(x == null) return null;
    if      (key<x.key) x.left  = delete(key,x.left); // 向左子树查找键为key的结点
    else if (key>x.key) x.right = delete(key,x.right); // 向右子树查找键为key的结点
    else{
      // 结点已经被找到，就是当前的x
      if(x.left==null) return x.right; // 若是左子树为空，则将右子树赋给父节点的连接
      if(x.right==null) return x.left; // 若是右子树为空，则将左子树赋给父节点的连接
      Node inherit = min(x.right); // 取得结点x的继承结点
      inherit.right = deleteMin(x.right); // 将继承结点从原来位置删除，并重置继承结点右连接
      inherit.left = x.left; // 重置继承结点左连接
      x = inherit; // 将x替换为继承结点
    }
    if(root == null) return root;
    x.height = max(height(x.left),height(x.right)) + 1; // 沿递归路径从下至上更新结点height属性
    x = reBalance(x); // 沿递归路径从下往上, 检测当前结点是否失衡，若失衡则进行平衡化
    return x;
  }
  public void delete (int key) {
    root = delete(key, root);
  }
 
  private void levelIterator () {
    LinkedList <Node> queue = new LinkedList <Node>();
    Node current = null;
    int childSize = 0;
    int parentSize = 1;
    queue.offer(root);
    while(!queue.isEmpty()) {
      current = queue.poll();//出队队头元素并访问
      System.out.print(current.val +"-->");
      if(current.left != null)//若是当前节点的左节点不为空入队
      {
        queue.offer(current.left);
        childSize++;
      }
      if(current.right != null)//若是当前节点的右节点不为空，把右节点入队
      {
        queue.offer(current.right);
        childSize++;
      }
      parentSize--;
      if (parentSize == 0)
      {
        parentSize = childSize;
        childSize = 0;
        System.out.println("");
      }
    }
  }
 
  public static void main (String [] args) {
    AVL avl = new AVL();
    avl.put(1,11);
    avl.put(2,22);
    avl.put(3,33);
    avl.put(4,44);
    avl.put(5,55);
    avl.put(6,66);
    avl.levelIterator();
  }
}