数据结构(十四) -- 树(六) -- 平衡二叉树(AVL树)

leo_messi94

已于 2023-04-26 23:14:21 修改

阅读量416

点赞数

分类专栏：数据结构文章标签：数据结构算法

于 2022-09-22 18:24:54 首次发布

本文链接：https://blog.csdn.net/weixin_39724194/article/details/126993063

版权

数据结构专栏收录该内容

31 篇文章 10 订阅

订阅专栏

1.二叉排序树可能的问题

1.1 问题分析：

对于一般的二叉搜索树，其期望高度（即为一棵平衡树时）为log2n，其各操作的时间复杂度O(log2n)同时也由此而决定。但是，在某些极端的情况下（如在插入的序列是有序的时），二叉搜索树将退化成近似链或链，此时，其操作的时间复杂度将退化成线性的，即O(n)。我们可以通过随机化建立二叉搜索树来尽量的避免这种情况，但是在进行了多次的操作之后，由于在删除时，我们总是选择将待删除节点的后继代替它本身，这样就会造成总是右边的节点数目减少，以至于树向左偏沉。这同时也会造成树的平衡性受到破坏，提高它的操作的时间复杂度。

1.2 一个案例：

给定一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树：

生成的二叉树如图：
在这里插入图片描述
问题分析：

左子树全部为空，从形式上看，更像一个单链表
插入速度没有影响
查询速度明显降低（因为需要依次比较），不能发挥二叉排序树的优势，因为每次还需要比较左子树，其查询速度比单链表还慢
解决方案：平衡二叉树

2. 平衡二叉树

2.1 基本介绍

平衡二叉树也叫平衡二叉搜索树，又被称为AVL树，可以保证查询效率较高
具有以下特点：它是一颗空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一颗平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等

2.2 举例说明平衡二叉树

在这里插入图片描述
上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2（以2为根节点的树的高度是3，而以8为根节点的树的高度是1）

3. 实现一个平衡二叉树

3.1 旋转

如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。这种失去平衡的可以概括为4种姿态：LL(左左)，LR(左右)，RR(右右)和RL(右左)。下面给出它们的示意图：
在这里插入图片描述

上图中的4棵树都是"失去平衡的AVL树"，从左往右的情况依次是：LL、LR、RL、RR。除了上面的情况之外，还有其它的失去平衡的AVL树，如下图：
在这里插入图片描述
上面的两张图都是为了便于理解，而列举的关于"失去平衡的AVL树"的例子。总的来说，AVL树失去平衡时的情况一定是LL、LR、RL、RR这4种之一，它们都由各自的定义：

LL：LeftLeft，也称为"左左"。插入或删除一个节点后，根节点的左子树的左子树还有非空子节点，导致"根的左子树的高度"比"根的右子树的高度"大2，导致AVL树失去了平衡。
例如，在上面LL情况中，由于"根节点(8)的左子树(4)的左子树(2)还有非空子节点"，而"根节点(8)的右子树(12)没有子节点"；导致"根节点(8)的左子树(4)高度"比"根节点(8)的右子树(12)"高2。
LR：LeftRight，也称为"左右"。插入或删除一个节点后，根节点的左子树的右子树还有非空子节点，导致"根的左子树的高度"比"根的右子树的高度"大2，导致AVL树失去了平衡。
例如，在上面LR情况中，由于"根节点(8)的左子树(4)的左子树(6)还有非空子节点"，而"根节点(8)的右子树(12)没有子节点"；导致"根节点(8)的左子树(4)高度"比"根节点(8)的右子树(12)"高2。
RL：RightLeft，称为"右左"。插入或删除一个节点后，根节点的右子树的左子树还有非空子节点，导致"根的右子树的高度"比"根的左子树的高度"大2，导致AVL树失去了平衡。
例如，在上面RL情况中，由于"根节点(8)的右子树(12)的左子树(10)还有非空子节点"，而"根节点(8)的左子树(4)没有子节点"；导致"根节点(8)的右子树(12)高度"比"根节点(8)的左子树(4)"高2。
RR：RightRight，称为"右右"。插入或删除一个节点后，根节点的右子树的右子树还有非空子节点，导致"根的右子树的高度"比"根的左子树的高度"大2，导致AVL树失去了平衡。
例如，在上面RR情况中，由于"根节点(8)的右子树(12)的右子树(14)还有非空子节点"，而"根节点(8)的左子树(4)没有子节点"；导致"根节点(8)的右子树(12)高度"比"根节点(8)的左子树(4)"高2。

如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。AVL失去平衡之后，可以通过旋转使其恢复平衡，下面分别介绍"LL(左左)，LR(左右)，RR(右右)和RL(右左)"这4种情况对应的旋转方法。

3.1.1 LL的旋转

LL失去平衡的情况，可以通过一次旋转让AVL树恢复平衡。如下图：
在这里插入图片描述
图中左边是旋转之前的树，右边是旋转之后的树。从中可以发现，旋转之后的树又变成了AVL树，而且该旋转只需要一次即可完成。

对于LL旋转，你可以这样理解为：LL旋转是围绕"失去平衡的AVL根节点"进行的，也就是节点k2；而且由于是LL情况，即左左情况，就用手抓着"左孩子，即k1"使劲摇。将k1变成根节点，k2变成k1的右子树，“k1的右子树"变成"k2的左子树”。

3.1.2 RR的旋转

理解了LL之后，RR就相当容易理解了。RR是与LL对称的情况！RR恢复平衡的旋转方法如下：
在这里插入图片描述

图中左边是旋转之前的树，右边是旋转之后的树。RR旋转也只需要一次即可完成。

3.1.3 LR的旋转

LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。如下图：
在这里插入图片描述
第一次旋转是围绕"k1"进行的"RR旋转"，第二次是围绕"k3"进行的"LL旋转"。

3.1.4 RL的旋转

RL是与LR的对称情况！RL恢复平衡的旋转方法如下：
在这里插入图片描述
第一次旋转是围绕"k3"进行的"LL旋转"，第二次是围绕"k1"进行的"RR旋转"。

3.2 代码：

public class AVLTreeDemo1 {
    public AVLTreeNode root; // 根结点

    /**
     * - 插入操作的入口
     * - @param insertValue
     */
    public void insert(long insertValue) {
        root = insert(root, insertValue);
    }

    /**
     * - 插入的递归实现
     * - @param subTree
     * - @param insertValue
     * - @return
     */
    private AVLTreeNode insert(AVLTreeNode subTree, long insertValue) {
        if (subTree == null) {
            return new AVLTreeNode(insertValue, null, null);
        }

        if (insertValue < subTree.value) { // 插入左子树
            subTree.left = insert(subTree.left, insertValue);
            if (unbalanceTest(subTree)) { // 插入后造成失衡
                if (insertValue < subTree.left.value) { // LL型失衡
                    subTree = leftLeftRotation(subTree);
                } else { // LR型失衡
                    subTree = leftRightRotation(subTree);
                }
            }
        } else if (insertValue > subTree.value) { // 插入右子树
            subTree.right = insert(subTree.right, insertValue);
            if (unbalanceTest(subTree)) { // 插入后造成失衡
                if (insertValue < subTree.right.value) { // RL型失衡
                    subTree = rightLeftRotation(subTree);
                } else { // RR型失衡
                    subTree = rightRightRotation(subTree);
                }
            }
        } else {
            throw new RuntimeException("duplicate value: " + insertValue);
        }

        return subTree;
    }

    /**
     * - RL型旋转
     * - @param k1 子树根节点
     * - @return
     */
    private AVLTreeNode rightLeftRotation(AVLTreeNode k1) {
        k1.right = leftLeftRotation(k1.right);
        return rightRightRotation(k1);
    }

    /**
     * - RR型旋转
     * - @param k1 k1 子树根节点
     * - @return
     */
    private AVLTreeNode rightRightRotation(AVLTreeNode k1) {
        AVLTreeNode k2;

        k2 = k1.right;
        k1.right = k2.left;
        k2.left = k1;

        return k2;
    }

    /**
     * - LR型旋转
     * - @param k3
     * - @return
     */
    private AVLTreeNode leftRightRotation(AVLTreeNode k3) {
        k3.left = rightRightRotation(k3.left);
        return leftLeftRotation(k3);
    }

    /**
     * - LL型旋转
     * <p>
     * - @author chenlongfei
     * <p>
     * - @param k2
     * <p>
     * - @return
     */
    private AVLTreeNode leftLeftRotation(AVLTreeNode k2) {
        AVLTreeNode k1;

        k1 = k2.left;
        k2.left = k1.right;
        k1.right = k2;

        return k1;
    }

    /**
     * - 判断是否失衡 - @param treeRoot - @return
     */
    private boolean unbalanceTest(AVLTreeNode treeRoot) {
        int leftHeight = treeRoot.left.height();
        int rightHeight = treeRoot.right.height();
        int diff = Math.abs(leftHeight - rightHeight);
        return diff > 1;
    }

    /**
     * - 删除操作的入口 - @param value
     */
    public void remove(long value) {
        root = remove(root, value);
    }

    /**
     * - 删除操作的递归实现
     * - @param tree
     * - @param value
     * - @return
     */
    private AVLTreeNode remove(AVLTreeNode tree, long value) {
        if (tree == null) {
            return tree;
        }

        if (value < tree.value) { // 要删除的节点在左子树
            tree.left = remove(tree.left, value);
        } else if (value > tree.value) { // 要删除的节点在右子树
            tree.right = remove(tree.right, value);
        } else if (tree.value == value) { // 要删除的节点就是本身
            if (tree.left != null && tree.right != null) { // 左右子树都存在
                if (tree.left.height() > tree.right.height()) {
                    /*
                     * - 如果tree的左子树比右子树高:
                     *
                     * - 1. 找出tree的左子树中的最大节点
                     * - 2. 将该最大节点的值赋值给tree。
                     * - 3. 删除该最大节点。
                     * - 这类似于用"tree的左子树中最大节点"做"tree"的替身
                     * - 采用这种方式的好处是：删除"tree的左子树中最大节点"之后，AVL树仍然是平衡的
                     */
                    AVLTreeNode max = getMaxNode(tree.left);
                    tree.value = max.value;
                    tree.left = remove(tree.left, max.value);
                } else {
                    /*
                     * - 如果tree的左子树不高于右子树:
                     * - 1. 找出tree的右子树中的最小节点
                     * - 2. 将该最小节点的值赋值给tree。
                     * - 3. 删除该最小节点。
                     * - 这类似于用"tree的右子树中最小节点"做"tree"的替身
                     * - 采用这种方式的好处是：删除"tree的左子树中最大节点"之后，AVL树仍然是平衡的
                     */
                    AVLTreeNode min = getMinNode(tree.right);
                    tree.value = min.value;
                    tree.right = remove(tree.right, min.value);
                }
            } else {
                tree = tree.left == null ? tree.right : tree.left;
            }
        } else {
            System.out.println("no node matched value: " + value);
        }
        return tree;
    }

    /**
     * - 获取值最大的节点
     * - @param node
     * - @return
     */
    private AVLTreeNode getMaxNode(AVLTreeNode node) {
        if (node == null) {
            return null;
        }

        if (node.right != null) {
            return getMaxNode(node.right);
        } else {
            return node;
        }
    }

    /**
     * - 获取值最小的节点
     * - @param node
     * - @return
     */
    private AVLTreeNode getMinNode(AVLTreeNode node) {
        if (node == null) {
            return null;
        }

        if (node.left != null) {
            return getMinNode(node.left);
        } else {
            return node;
        }
    }
}

// AVL树的节点
@Data
class AVLTreeNode {
    long value; // 节点存储的数值
    AVLTreeNode left; // 左孩子
    AVLTreeNode right; // 右孩子

    public AVLTreeNode(long value, AVLTreeNode left, AVLTreeNode right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }

    //返回 以该结点为根结点的树的高度
    public int height() {
        return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
    }
}

3. 测试：

public static void preorder(AVLTreeNode currentRoot) {
    if (currentRoot != null) {
        System.out.print(currentRoot.value + "\t");
        preorder(currentRoot.left);
        preorder(currentRoot.right);
    }
}

public static void main(String[] args) {
    AVLTree tree = new AVLTree();
    int arr[] = { 3, 2, 1, 4, 5, 6, 7, 16, 15, 14, 13, 12, 11, 10, 8, 9 };
    for (int a : arr) {
        tree.insert(a);

    }
    preorder(tree.root);

}

输出：

7	4	2	1	3	6	5	13	11	9	8	10	12	15	14	16

leo_messi94

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构(十四) -- 树(六) -- 平衡二叉树(AVL树)

平衡二叉树也叫平衡二叉搜索树，又被成为AVL树，可以保证查询效率较高具有以下特点：它是一颗空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一颗平衡二叉树。平很二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。
复制链接

扫一扫

专栏目录