最早的自平衡BST——AVL树（AVL Tree）

最新推荐文章于 2024-06-10 20:39:17 发布

啦啦啦小骑士

最新推荐文章于 2024-06-10 20:39:17 发布

阅读量249

点赞数

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

本文链接：https://blog.csdn.net/Knightletter/article/details/103302662

版权

数据结构与算法专栏收录该内容

13 篇文章 0 订阅

订阅专栏

设计背景

二分搜索树（Binary Search Tree）拥有相对高效的查找能力，但是依然存在很大的缺陷。
当添加的所有元素都比现有的元素大或者小时，二分搜索树将会退化成一个链表（LinkedList）。
在这里插入图片描述
即使只有部分元素发生这种状况，也会使二分搜索树变得极不平衡，大大降低树结构的效率。

这种问题产生的根源在于二分搜索树没有一套自平衡的机制，只有添加的元素拥有足够的随机性时它才能趋向于平衡。
AVL树就是最早发明的一种自平衡二分搜索树，在AVL树中，每一个节点都会存储相应的高度值，每一个节点左右子集的高度差不能大于1，一旦平衡被打破，将会触发相应的旋转操作进行平衡维护。

结构分析

【结构类型】树形结构
【底层实现】Node模型（key+value+左指针+右指针）
【核心方法】
public void add(K key, V value); //向AVL树添加元素
private Node leftRotate(Node y); //左旋转
private Node rightRotate(Node y); //右旋转
public V remove(K key); //从AVL树移除元素

平衡原理

自平衡触发时机是当前节点的左子树高度与右子树高度相差 > 1时，
由此可以推导出平衡因子的概念：
平衡因子 = 该节点左子树的高度 - 该节点右子树的高度
当平衡因子的绝对值 > 1时，触发自平衡。

1. LL

若失衡发生在当前节点左侧的左侧(LL)，则触发右旋转操作：
在这里插入图片描述代码演示：

Node x = y.left;
Node T3 = x.right;

x.right = y;
y.left = T3;

2. RR

若失衡发生在当前节点右侧的右侧(RR)，则触发左旋转操作：
在这里插入图片描述代码演示：

Node x = y.right;
Node T2 = x.left;

x.left = y;
y.right = T2;

3. LR

若失衡发生在当前节点左侧的右侧（LR），先对左子树进行左旋转，让LR变成LL，再按照LL的标准触发一次右旋转操作即可：
在这里插入图片描述
代码演示：

node.left = leftRotate(node.left);
return rightRotate(node);

4. RL

若失衡发生在当前节点的右侧的左侧（RL），先对右子树进行右旋转，让RL变成RR，再按照RR的标准触发一次左旋转操作即可：
在这里插入图片描述
代码演示：

node.right = rightRotate(node.right);
return leftRotate(node);

代码实现

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;
    }

    /**
     * 方法：向AVL树添加新的元素
     *
     * @param key   键
     * @param value 值
     */
    public void add(K key, V value) {
        root = add(root, key, value);
    }

    /**
     * 重载方法：针对特定节点进行添加元素操作
     *
     * @param node  节点
     * @param key   键
     * @param value 值
     * @return
     */
    private Node add(Node node, K key, V value) {
        // 如果当前node为空，则返回一个新的节点
        if (node == null) {
            size++;
            return new Node(key, value);
        }
        // 如果新增元素的key比当前节点小（大），则向左（右）传递
        // 如果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 {
            node.value = value;
        }
        // 更新节点高度
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
        // 获取平衡因子
        int balanceFactor = getBalanceFactor(node);
        // 若失衡发生在当前节点左侧的左侧(LL)，则触发左旋转操作
        if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {
            return rightRotate(node);
        }
        // 若失衡发生在当前节点右侧的右侧(RR)，则触发右旋转操作
        if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0) {
            return leftRotate(node);
        }
        // 若失衡发生在当前节点左侧的右侧（LR）
        if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {
            // 对左子树进行左旋转，让LR变成LL
            node.left = leftRotate(node.left);
            // 按照LL的标准触发一次右旋转操作
            return rightRotate(node);
        }
        // 若失衡发生在当前节点的右侧的左侧（RL）
        if (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {
            // 对右子树进行右旋转，让RL变成RR
            node.right = rightRotate(node.right);
            // 按照RR的标准触发一次左旋转操作
            return leftRotate(node);
        }
        return node;
    }

    /**
     * 方法：左旋转
     *
     * @param y 触发旋转的节点
     * @return 新的父节点
     */
    private Node leftRotate(Node y) {
        Node x = y.right;
        Node T2 = x.left;
        // 旋转
        x.left = y;
        y.right = T2;
        // 更新高度
        x.height = 1 + Math.max(getHeight(x.left), getHeight(x.right));
        y.height = 1 + Math.max(getHeight(y.left), getHeight(y.right));
        return x;
    }

    /**
     * 方法：右旋转
     *
     * @param y 触发旋转的节点
     * @return 新的父节点
     */
    private Node rightRotate(Node y) {
        Node x = y.left;
        Node T3 = x.right;
        // 旋转
        x.right = y;
        y.left = T3;
        // 更新高度
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        return x;
    }

    /**
     * 方法：从AVL树移除元素
     *
     * @param key 被移除节点的key值
     * @return 被移除节点的value值
     */
    public V remove(K key) {
        Node node = getNode(root, key);
        if (node != null) {
            root = remove(root, key);
            return node.value;
        }
        return null;
    }

    /**
     * 私有方法：针对特定节点进行移除操作
     *
     * @param node 节点
     * @param key  节点的key
     * @return 完成操作后返回的节点
     */
    private Node remove(Node node, K key) {
        // 如果当前节点为空，则返回null
        if (node == null) {
            return null;
        }
        // 定义一个临时变量
        Node retNode;
        // 若当前节点比要删除的节点大，则向左传递，反之向右
        // 将返回的结果挂接在当前节点相应的方向，同时保存节点
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            retNode = node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            retNode = node;
        } else { // 当前节点即为要删除的节点时
            // 若待删除节点左子树为空，将其左子树保存到临时变量中
            // 反之右...
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                retNode = rightNode;
            } else if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                retNode = leftNode;
            } else { // 当左右子树均不为空时
                // 用比待删除节点大的最小节点顶替被删除节点
                Node successor = minimum(node.right);
                successor.left = node.left;
                successor.right = remove(node.right, successor.key);
                node.left = node.right = null;
                retNode = successor;
            }
        }
        // 处理删除节点为叶子节点时的特殊情况
        if (retNode == null) {
            return null;
        }
        // 更新高度值
        retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));
        // 计算平衡因子
        int balanceFactor = getBalanceFactor(retNode);
        // 若失衡发生在当前节点左侧的左侧(LL)，则触发左旋转操作
        if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {
            return rightRotate(node);
        }
        // 若失衡发生在当前节点右侧的右侧(RR)，则触发右旋转操作
        if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0) {
            return leftRotate(node);
        }
        // 若失衡发生在当前节点左侧的右侧（LR）
        if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {
            // 对左子树进行左旋转，让LR变成LL
            node.left = leftRotate(node.left);
            // 按照LL的标准触发一次右旋转操作
            return rightRotate(node);
        }
        // 若失衡发生在当前节点的右侧的左侧（RL）
        if (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {
            // 对右子树进行右旋转，让RL变成RR
            node.right = rightRotate(node.right);
            // 按照RR的标准触发一次左旋转操作
            return leftRotate(node);
        }
        return retNode;
    }

    /**
     * 方法：获取节点高度
     *
     * @param node 节点
     * @return 节点的高度
     */
    private int getHeight(Node node) {
        // 如果该节点不存在，则返回0
        if (node == null) {
            return 0;
        }
        return node.height;
    }

    /**
     * 方法：计算平衡因子
     *
     * @param node 节点
     * @return 平衡因子
     */
    private int getBalanceFactor(Node node) {
        // 如果当前节点不存在，则返回0
        if (node == null) {
            return 0;
        }
        // 平衡因子 = 该节点左子树的高度 - 该节点右子树的高度
        return getHeight(node.left) - getHeight(node.right);
    }

    /**
     * 方法：从指定根节点处出发寻找指定的元素
     *
     * @param node 指定的根节点
     * @param key  元素key
     * @return 待寻找的节点
     */
    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 {
            return getNode(node.right, key);
        }
    }

    /**
     * 方法：从指定的根节点处出发寻找最小的元素
     *
     * @param node 指定的根节点
     * @return
     */
    private Node minimum(Node node) {
        if (node.left == null) {
            return node;
        }
        return minimum(node.left);
    }

    public int getSize() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

}

啦啦啦小骑士

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
最早的自平衡BST——AVL树（AVL Tree）

设计背景二分搜索树（Binary Search Tree）拥有相对高效的查找能力，但是依然存在很大的缺陷。当添加的所有元素都比现有的元素大或者小时，二分搜索树将会退化成一个链表（LinkedList）。即使只有部分元素发生这种状况，也会使二分搜索树变得极不平衡，大大降低树结构的效率。这种问题产生的根源在于二分搜索树没有一套自平衡的机制，只有添加的元素拥有足够的随机性时它才能趋向于平衡。...
复制链接

扫一扫