AVL树

AVL 树

• AVL 树是一种平衡的二叉搜索树（BST），它的结构和操作与BST都是一致的，只是多加了一个平衡条件
• AVL树的平衡条件是：它的任一节点的左子树和右子树的高度差的绝对值小于等于1

概念回顾：

• 树的高度等于其根节点的高度
• 节点的高度等于该节点与它最下面的叶子节点之间的边数

由定义可知，叶子节点的高度为0
为了便于计算，规定叶子节点的（假想的）子节点的高度为-1

那么判定一颗树是否是AVL树则是通过计算root节点的左右两个子节点的高度差，如果高度差的绝对值小于等于1，那么就是AVL树，否则不是。

最简单的办法就是在节点中存储节点的高度信息，这样可以迅速的计算出高度差（平衡因子）

废话不多说，用代码来描述更直接，下面是go语言的代码片段

// 节点类型
type node_t struct {
    Key    int
    height int
    left   *node_t
    right  *node_t
}

// 这是获取节点高度的get函数，避免每次获取高度都要判断node是否为nil
func height(node *node_t) int {
    if node == nil {
        return -1
    }
    return node.height
}

// 平衡因子：等于左子树的高度-右子树的高度
func balance_factor(node *node_t) int {
    if node == nil { // 空树，算作平衡
        return 0
    }
    return height(node.left) - height(node.right)
}

下面观察一下造成树不平衡的几种情况：

我们从空树开始构造，慢慢观察造成树不平衡的原因
先看只有一个节点的树：

很明显树是平衡的，节点3没有子节点，即左右两个子节点的高度都为-1，差为0，即：平衡

插入一个节点
插入一个节点可能出现的情况有两种，要么作为3的左子节点，要么作为3的右子节点，如图所示：

这两种情况，树都是平衡的：
左图节点3的平衡因子等于：0 - (-1) = 1
右图节点3的平衡因子等于：(-1) - 0 = -1

下面先考虑左图的情况，右图情况与左图是对称的，后面会给出对称的情况
我们继续插入一个节点，有3种可能：
第一种可能是插入的节点比3大，那么作为3的右子节点，例如：

上面的树是平衡的，不是我们要考虑的情况

第二种可能：插入的节点比1小（下面的左图）
第三种可能：插入的节点比3小，但是比1大（下面的右图）

左图节点3的平衡因子等于：1 - (-1) = 2
右图节点3的平衡因子等于：1 - (-1) = 2
这两种情况下树是不平衡的，那么在插入操作完成后需要对树进行调整（fix it），让树始终保持平衡
观察上面左图，根节点3有左节点1，左节点1有左节点0，这种情况称之为：left-left case
观察上面右图，根节点3有左节点1，左节点1有右节点2，这种情况称之为：left-right case

现在回过头来看看对称的情况

上图是对称的两种情况：
左图节点3的平衡因子等于：(-1) - 1 = -2
右图节点3的平衡因子等于：(-1) - 1 = -2
观察上面左图，根节点3有右节点5，右节点5有右节点6，这种情况称之为：right-right case
观察上面右图，根节点3有右节点5，右节点5有左节点4，这种情况称之为：right-left case

导致树不平衡的4种情况已经找到了，下面就要去fix it，使树重新平衡。
这4种情况两两对称，LL和RR对称，LR和RL对称。

我们先看LL和RR这两种情况

所谓fix就是让树重新平衡（AVL性质），且还是有序（BST性质）
再看下LL和RR这两种情况的树

对于LL的情况，只需要将节点1往上拉，使其成为根节点，节点3在重力作用下变成节点1的右节点，树再次平衡，且仍是有序的。
这个操作称之为对节点3应用一次向右旋转（single rotation），即把节点1作为支点，把节点3往下（顺时针）旋转。注意支点变成了根节点

同理，对于RR的情况，只需要将节点5往上拉，使其成为根节点，节点3在重力作用下变成节点5的左节点，树再次平衡，且仍是有序的。
这个操作称之为对节点3应用一次向左旋转（single rotation），即把节点5作为支点，把节点3往下（逆时针）旋转。注意支点变成了根节点

再看LR和RL这两种情况

这两种情况，如果只是简单的把节点1（左图）或节点5（右图）上拉就不好使了，因为树看起来是平衡了，但是却不是有序的了（不满足BST性质），如下图所示：

解决办法是做两次旋转（double rotation）
对于LR的情况：
先对根节点3的左子树根节点1应用一次向左旋转（以节点2为支点），将树转换成LL的情况后，再对根节点3应用一次右旋转
对于RL的情况：
先对根节点3的右子树根节点5应用一次向右旋转（以节点4为支点），将树转换成RR的情况后，再对根节点3应用一次左旋转

第一次旋转如下图所示：

第二次旋转如下图所示：

代码实现(golang)如下：

avl/node.go

package avl

// 节点类型
type node_t struct {
    Key    int
    height int
    left   *node_t
    right  *node_t
}

// 这是获取节点高度的get函数，避免每次获取高度都要判断node是否为nil
func height(node *node_t) int {
    if node == nil {
        return -1
    }
    return node.height
}

// 更新节点的高度信息
func update_height(node *node_t) {
    if node != nil {
        node.height = max(height(node.left), height(node.right)) + 1
    }
}

// 平衡因子：等于左子树的高度-右子树的高度
func balance_factor(node *node_t) int {
    if node == nil { // 空树，算作平衡
        return 0
    }
    return height(node.left) - height(node.right)
}

func max(x int, y int) int {
    if x > y {
        return x
    }
    return y
}

// 右转
func fix_ll_case(k2 *node_t) *node_t {
    k1 := k2.left
    k2.left = k1.right
    k1.right = k2
    update_height(k2)
    update_height(k1)
    return k1
}

// 左转
func fix_rr_case(k1 *node_t) *node_t {
    k2 := k1.right
    k1.right = k2.left
    k2.left = k1
    update_height(k1)
    update_height(k2)
    return k2
}

// 先左转后右转
func fix_lr_case(k3 *node_t) *node_t {
    k3.left = fix_rr_case(k3.left)
    return fix_ll_case(k3)
}

// 先右转后左转
func fix_rl_case(k1 *node_t) *node_t {
    k1.right = fix_ll_case(k1.right)
    return fix_rr_case(k1)
}

// 分4种情况分别fix
func rebalance(root *node_t) *node_t {
    bf := balance_factor(root)
    if bf == 2 {
        lbf := balance_factor(root.left)
        if lbf == 1 {
            root = fix_ll_case(root)
        } else {
            root = fix_lr_case(root)
        }
    } else if bf == -2 {
        rbf := balance_factor(root.right)
        if rbf == 1 {
            root = fix_rl_case(root)
        } else {
            root = fix_rr_case(root)
        }
    }
    return root
}

// 插入节点
func add(root *node_t, key int) *node_t {
    if root == nil {
        return &node_t{Key: key, height: 0}
    }
    if key < root.Key {
        root.left = add(root.left, key)
    } else if key > root.Key {
        root.right = add(root.right, key)
    }
    update_height(root)
    return rebalance(root)
}

// 删除节点，注意使用的技巧是：总是删除叶子节点
func remove(root *node_t, key int) *node_t {
    if root == nil {
        return nil
    }
    if root.Key == key {
        if root.height == 0 { // 叶子节点，直接删除
            root = nil
        } else if balance_factor(root) <= 0 { // 有右孩子
            root.Key = find_min(root.right).Key
            root.right = remove(root.right, root.Key)
        } else { // 有左孩子
            root.Key = find_max(root.left).Key
            root.left = remove(root.left, root.Key)
        }
    } else if key < root.Key {
        root.left = remove(root.left, key)
    } else {
        root.right = remove(root.right, key)
    }
    update_height(root)
    return rebalance(root)
}

func find_min(root *node_t) *node_t {
    if root == nil {
        return nil
    }
    node := root
    for node.left != nil {
        node = node.left
    }
    return node
}

func find_max(root *node_t) *node_t {
    if root == nil {
        return nil
    }
    node := root
    for node.right != nil {
        node = node.right
    }
    return node
}

func find(root *node_t, key int) *node_t {
    if root == nil {
        return nil
    }
    if key < root.Key {
        return find(root.left, key)
    }
    if key > root.Key {
        return find(root.right, key)
    }
    return root
}

创建一个tree类型，封装树的操作，便于使用：

avl/tree.go

package avl

type Tree_t struct {
    root *node_t
}

func (tree *Tree_t) Find(key int) *node_t {
    return find(tree.root, key)
}

func (tree *Tree_t) FindMin() *node_t {
    return find_min(tree.root)
}

func (tree *Tree_t) FindMax() *node_t {
    return find_max(tree.root)
}

func (tree *Tree_t) Add(key int) {
    tree.root = add(tree.root, key)
}

func (tree *Tree_t) Remove(key int) {
    tree.root = remove(tree.root, key)
}

对于节点高度信息的更新，只有在改变树结构的操作里更新高度信息，比如插入，删除，左转，右转操作
在插入和删除操作里，是在调用rebalance函数之前更新节点的高度信息，因为rebalance操作是根据树的高度信息来判定是否需要fix树结构的。

关于删除操作的技巧分析，参考：Binary Search Tree