第12章 AVL平衡树是怎么平衡的？

最新推荐文章于 2023-09-17 18:44:54 发布

peihenglee

最新推荐文章于 2023-09-17 18:44:54 发布

阅读量433

点赞数 1

分类专栏：学习笔记之《玩转算法系列--数据结构精讲》文章标签： avl 算法数据结构

本文链接：https://blog.youkuaiyun.com/peihenglee2016/article/details/106867478

版权

学习笔记之《玩转算法系列--数据结构精讲》专栏收录该内容

18 篇文章

订阅专栏

本文深入探讨AVL平衡树的概念，包括其历史背景、平衡条件、节点高度与平衡因子的计算，以及左旋、右旋操作的实现。此外，文章还讲解了AVL树在插入和删除元素时如何维持平衡，最后介绍了基于AVL树的集合和映射的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

第十二章 AVL平衡树

12-1 平衡树和AVL
12-2 计算节点高度和平衡因子
12-3 检查二分搜索树性质和平衡性
12-4 旋转操作的基本原理
12-5 左旋转和右旋转的实现
12-6 LR和RL
12-7 从AVL树中删除元素
12-8 基于AVL树的集合和映射

12-1 平衡树和AVL
AVL是两个发明人名字的缩写：G. M. Adelson-Velsky and E. M. Landis
1962年论文首次提出，是最早的自平衡二分搜索树结构。

什么是平衡二叉树？
对于任意一节，左子树和右子树的高度差不能为超过1
平衡二叉树的高度和节点数量之间的关系也是O(logn)的

标注节点的高度
计算平衡因子

标注节点的高度：对于叶子节点来说，它对应的高度就是1，所以2这个节点对应的高度就是1，4这个节点由于它下面只有一个叶子节点，所以它对应的高度就是2，7这个节点它是叶子节点所以它的高度也是1，那么对于5这个节点，它有左右两个子树，左子树高度为2，右子树高度为1，相应的5这个节点的高度就是左右子树中最高的那棵树再加上1，这个1就是它本身，因此5节点的高度是3，以此类推。

平衡因子：实际上就是指对每个节点而言，它的左右子树的高度差。这里对于2这个节点，它没有左右子树，因此它的平衡因子就是 0-0 = 0，相应的对于4这个节点，它的左子树对应的高度为1，右子树为空高度为0，那么4节点的平衡因此为1，以此类推，这里那个12节点，左子树高度为4，右子树高度为2，因此节点12的平衡因子为4-2=2。

通过平衡因子就可以看出来，一旦在一棵树中它的平衡因子大于等于2或者小于等于-2，那么这整棵树就不再是一棵平衡二叉树。

12-2 计算节点高度和平衡因子
这里我们会将AVL树和二分搜索树进行比较，AVL树的实现会基于二分搜索树实现。

import java.util.ArrayList;
public class AVLTree<K extends Comparable<K>, V> {
    private class Node{
        public K key;
        public V value;
        public Node left, right;
        public int height;
        public Node(K key, V value){
            this.key = key;
            this.value = value;
            left = null;
            right = null;
            height = 1;
        }
    }
    private Node root;
    private int size;
    public AVLTree(){
        root = null;
        size = 0;
    }
    public int getSize(){
        return size;
    }
    public boolean isEmpty(){
        return size == 0;
    }
    // 获得节点node的高度
    private int getHeight(Node node){
        if(node == null)
            return 0;
        return node.height;
    }
    // 获得节点node的平衡因子
    private int getBalanceFactor(Node node){
        if(node == null)
            return 0;
        return getHeight(node.left) - getHeight(node.right);
    }
    // 向二分搜索树中添加新的元素(key, value)
    public void add(K key, V value){
        root = add(root, key, value);
    }
    // 向以node为根的二分搜索树中插入元素(key, value)，递归算法
    // 返回插入新节点后二分搜索树的根
    private Node add(Node node, K key, V value){

        if(node == null){
            size ++;
            return new Node(key, value);
        }
        if(key.compareTo(node.key) < 0)
            node.left = add(node.left, key, value);
        else if(key.compareTo(node.key) > 0)
            node.right = add(node.right, key, value);
        else // key.compareTo(node.key) == 0
            node.value = value;
        // 更新height
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
        // 计算平衡因子
        int balanceFactor = getBalanceFactor(node);
        if(Math.abs(balanceFactor) > 1)
            System.out.println("unbalanced : " + balanceFactor);
        return node;
    }
    // 返回以node为根节点的二分搜索树中，key所在的节点
    private Node getNode(Node node, K key){
        if(node == null)
            return null;
        if(key.equals(node.key))
            return node;
        else if(key.compareTo(node.key) < 0)
            return getNode(node.left, key);
        else // if(key.compareTo(node.key) > 0)
            return getNode(node.right, key);
    }
    public boolean contains(K key){
        return getNode(root, key) != null;
    }
    public V get(K key){
        Node node = getNode(root, key);
        return node == null ? null : node.value;
    }
    public void set(K key, V newValue){
        Node node = getNode(root, key);
        if(node == null)
            throw new IllegalArgumentException(key + " doesn't exist!");
        node.value = newValue;
    }
    // 返回以node为根的二分搜索树的最小值所在的节点
    private Node minimum(Node node){
        if(node.left == null)
            return node;
        return minimum(node.left);
    }
    // 删除掉以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMin(Node node){
        if(node.left == null){
            Node rightNode = node.right;
            node.right = null;
            size --;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }
    // 从二分搜索树中删除键为key的节点
    public V remove(K key){
        Node node = getNode(root, key);
        if(node != null){
            root = remove(root, key);
            return node.value;
        }
        return null;
    }
    private Node remove(Node node, K key){
        if( node == null )
            return null;
        if( key.compareTo(node.key) < 0 ){
            node.left = remove(node.left , key);
            return node;
        }
        else if(key.compareTo(node.key) > 0 ){
            node.right = remove(node.right, key);
            return node;
        }
        else{   // key.compareTo(node.key) == 0
            // 待删除节点左子树为空的情况
            if(node.left == null){
                Node rightNode = node.right;
                node.right = null;
                size --;
                return rightNode;
            }
            // 待删除节点右子树为空的情况
            if(node.right == null){
                Node leftNode = node.left;
                node.left = null;
                size --;
                return leftNode;
            }
            // 待删除节点左右子树均不为空的情况
            // 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
            // 用这个节点顶替待删除节点的位置
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            node.left = node.right = null;
            return successor;
        }
    }
    public static void main(String[] args){
        System.out.println("Pride and Prejudice");
        ArrayList<String> words = new ArrayList<>();
        if(FileOperation.readFile("pride-and-prejudice.txt", words)) {
            System.out.println("Total words: " + words.size());
            AVLTree<String, Integer> map = new AVLTree<>();
            for (String word : words) {
                if (map.contains(word))
                    map.set(word, map.get(word) + 1);
                else
                    map.add(word, 1);
            }
            System.out.println("Total different words: " + map.getSize());
            System.out.println("Frequency of PRIDE: " + map.get("pride"));
            System.out.println("Frequency of PREJUDICE: " + map.get("prejudice"));
        }
        System.out.println();
    }
}

12-3 检查二分搜索树性质和平衡性
（1）判断二叉树是否是一棵二分搜索树

  // 判断该二叉树是否是一棵二分搜索树
    public boolean isBST(){
        ArrayList<K> keys = new ArrayList<>();
        inOrder(root, keys);
        for(int i = 1 ; i < keys.size() ; i ++)
            if(keys.get(i - 1).compareTo(keys.get(i)) > 0)
                return false;
        return true;
    }
    private void inOrder(Node node, ArrayList<K> keys){
        if(node == null)
            return;
        inOrder(node.left, keys);
        keys.add(node.key);
        inOrder(node.right, keys);
    }

（2）判断该二叉树是否是一棵平衡二叉树

    // 判断该二叉树是否是一棵平衡二叉树
    public boolean isBalanced(){
        return isBalanced(root);
    }
    // 判断以Node为根的二叉树是否是一棵平衡二叉树，递归算法
    private boolean isBalanced(Node node){
        if(node == null)
            return true;
        int balanceFactor = getBalanceFactor(node);
        if(Math.abs(balanceFactor) > 1)
            return false;
        return isBalanced(node.left) && isBalanced(node.right);
    }

12-4 旋转操作的基本原理
本节主要介绍AVL树的左旋转和右旋转。
首先讨论一下在什么时候维护平衡：加入节点后，沿着节点向上维护平衡性。

    // 向以node为根的二分搜索树中插入元素(key, value)，递归算法
    // 返回插入新节点后二分搜索树的根
    private Node add(Node node, K key, V value){
        if(node == null){
            size ++;
            return new Node(key, value);
        }
        if(key.compareTo(node.key) < 0)
            node.left = add(node.left, key, value);
        else if(key.compareTo(node.key) > 0)
            node.right = add(node.right, key, value);
        else // key.compareTo(node.key) == 0
            node.value = value;

        // 更新height
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));

        // 计算平衡因子
        int balanceFactor = getBalanceFactor(node);
//        if(Math.abs(balanceFactor) > 1)
//            System.out.println("unbalanced : " + balanceFactor);

        // 平衡维护
        if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0)
            ; // 实现平衡维护，下一小节进行具体实现：）
        return node;
    }

简单说明：对于这个y节点来说，以y节点为根节点的树已经不满足平衡二叉树了，并且整体是向左倾斜的。为了不失一般性，这几个节点它们的右侧相应的可能也会有子树，我们把它画出来。对于z这个节点，它的左右子树写为T1,T2，这里T1,
T2可以为空，这里只是不失一般化处理，让z这个节点拥有左右两棵子树，但是z是一个叶子节点是完全没有问题的。同理，对于x节点，它可能有右节点，记为T3，对于y这个节点，它也有可能有右子树T4.
这里我们需要注意，在y这个节点上，左子树的高度减去右子树的高度是大于1的，与此同时，对于x节点它的平衡因子是大于等于0的，也就是左子树的高度是大于右子树的高度的。对于二分搜索树来说，就存在这个关系：
T1 < z < T2 < x < T3 < y < T4, T1中的值是最小的，其次是z的值，其次是T2的值以此类推。

那么现在在我们图中，对于y这个节点来说它的左子树高度过于高了，所以我们希望经过右旋转操作，使得y这个节点保持平衡性，同时整棵树不失二分搜索树性质。

第一步：首先我们让x节点的右子树T3，变为以y节点为根的子树。

第二步：之后我们让y这个节点的左子树变成刚刚x节点的右子树T3，然后让x成为这个新二叉树的根节点。

变化之后，依旧满足二分搜索树的性质。下面来看一下为什么保存了平衡二叉树的性质：

由于在左侧二叉树中，y是不平衡节点，而以x，z为根的二叉树是平衡二叉树；右侧二叉树中，以z为节点的二叉树相当于没有动，依然保持平衡性，如果以z为根节点的二叉树保持平衡性的话说明T1和T2的高度差不会超过1，这里假设T1和T2中最大的高度值是h的话，那么z这个节点相应的高度值为h+1，相应的右侧z也是h+1；
由于x本身也是保持平衡的，并且对于x来说它的平衡因子是大于等于0的，也就是说左子树的高度大于右子树的高度的，所以x节点本身也是保持平衡的，x节点的平衡因子最大为1，要么是0要么是1，对应就是T3这个树的高度，要么是h+1要么是h，对于x这个节点来说它的高度值就是h+2
我们再来看y这个节点，y在这里打破了平衡，换句话说它的左右子树高度差是大于1的，但是在这里它的高度差最大是2，因为我们是向以y节点为根的这棵树中添加了一个元素之后使得y这个节点打破了平衡，那么原来y这个节点是平衡的，意思就是左右子树高度差最多为1，那么我们添加了一个新的节点之后，这个高度差只有可能为2而不可能为3，因此T4这棵树高度为h.

重点：在右侧二叉树中，z的高度为h+1，对于T3这个子树来说它的高度要么是h+1，要么是h, 而T4它的高度为h，所以整体来看，对于y这个节点它也是相应的保持平衡的（左右子树的高度差最多为1），那么这里y节点的高度要么是h+2，要么是h+1，具体是谁取决于T3的高度；而不管T3取值多少，对于x这个节点来说依旧是平衡的，y和z两个节点的高度差是不会超过1的。这样我们就可以说从左边的这棵树转到右边的这棵树，x是这棵树的新根节点，从x的角度来看这棵新树，它也保持着平衡二叉树的性质，同时也保持着二分搜索树的性质，这正是我们想要的。

12-5 左旋转和右旋转的实现

简单代码实现右旋转：
在这里插入图片描述

private Node rightRotate(Node y) {
        Node x = y.left;
        Node T3 = x.right;
        // 向右旋转过程
        x.right = y;
        y.left = T3;
        // 更新height
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        return x;
    }

左旋转：插入的元素在不平衡的节点的右侧
同样的，左旋转也是既保存了二分搜索树的性质，同时也保存了平衡二叉树的性质。

简单代码实现左旋转：

 private Node leftRotate(Node y) {
        Node x = y.right;
        Node T2 = x.left;
        // 向左旋转过程
        x.left = y;
        y.right = T2;
        // 更新height
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        return x;
    }

这里，我们也需要对左右旋转方法进行平衡的维护：

		// 平衡维护
		// LL
        if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0)
            return rightRotate(node);
        //RR
        if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0)
            return leftRotate(node);
        return node;

12-6 LR和RL
上一章介绍的左右旋转情况可以称作 LL 和 RR：

接下来我们来考虑 LR 和 RL：
（1）对于LR的情况：首先对x进行左旋转，从而转化成了LL的情况

// 平衡维护
// LR
		if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }

（2）对于RL的情况：首先对x进行右旋转，从而转化成了RR的情况

// 平衡维护
// RL
        if (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }

12-7 从AVL树中删除元素
我们只需要将下面的代码添加到remove部分：
其实这节没怎么听懂，复习到这里的时候需要再仔细学习教学视频。

		if(retNode == null)
            return null;
        // 更新height
        retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));
        // 计算平衡因子
        int balanceFactor = getBalanceFactor(retNode);
        // 平衡维护
        // LL
        if (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0)
            return rightRotate(retNode);
        // RR
        if (balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0)
            return leftRotate(retNode);
        // LR
        if (balanceFactor > 1 && getBalanceFactor(retNode.left) < 0) {
            retNode.left = leftRotate(retNode.left);
            return rightRotate(retNode);
        }
        // RL
        if (balanceFactor < -1 && getBalanceFactor(retNode.right) > 0) {
            retNode.right = rightRotate(retNode.right);
            return leftRotate(retNode);
        }
        return retNode;

//successor.right = removeMin(node.right);
successor.right = remove(node.right, successor.key);
successor.left = node.left;

关于AVL的时间复杂度：AVL因为是平衡树，所以树的高度最高是 logn 级别，各项操作也都是 logn 级别的。

12-8 基于AVL树的集合和映射

基于AVL树的 set 和 map
AVL树的优化，AVL树的局限性