树——avl树

AVL树

概述

　　AVL树是一种自平衡二叉搜索树（Balanced Binary Search Tree, BBST），由G. M. Adelson-Velsky和E. M. Landis在1962年发明，因此以他们的名字首字母命名。AVL树保证了任何节点的两个子树的高度最多相差1，这使得在AVL树中进行查找、插入和删除等操作时，可以确保有良好的最坏情况下的时间复杂度，即O(log n)。

主要特点

　　自平衡：当插入或删除节点导致树失去平衡（即任意节点的两个子树高度差大于1）时，AVL树通过一系列旋转操作重新调整树结构，恢复其平衡性。

失衡情况

　　平衡因子（balance factor）bf；

LL（左左）

• 失衡节点（图中 8 红色）的 bf > 1，即左边更高
• 失衡节点的左孩子（图中 6）的 bf >= 0 即左孩子这边也是左边更高或等高

LR（左右）

• 失衡节点（图中 8）的 bf > 1，即左边更高
• 失衡节点的左孩子（图中 3 红色）的 bf < 0 即左孩子这边是右边更高

RL（右左）

• 失衡节点（图中 3）的 bf <-1，即右边更高
• 失衡节点的右孩子（图中 6 红色）的 bf > 0，即右孩子这边左边更高

RR（右右）

• 失衡节点（图中 3）的 bf <-1，即右边更高
• 失衡节点的右孩子（图中 5 ）的 bf <= 0，即右孩子这边右边更高或等高

函数

• 　　求高度代码 height(node : AVLNode) : int;
• 　　更新高度代码 updateHeight(node : AVLNode) : void;
• 　　平衡因子 bf(node AVLNode) : int;
• 　　右旋 rightRotate(red : AVLNode) : AVLNode;(LL)
• 　　左旋 leftRotete(red : AVLNode) : AVLNode;(RR)
• 　　左右旋 leftRightRotate(root : AVLNode) : AVLNode;(LR)
• 　　右左旋 rightLeftRotate(root : AVLNode) : AVLNode;(RL)
• 　　判断及调整平衡代码 balance(node : AVLNode) : AVLNode;
• 　　新增 put(key : int , value : Object) : void;
• 　　删除 doRemove(node : AVLNode , key : int) : AVLNode;

代码

　　将高度作为节点的一个属性。

/**
 * <h3>AVL 树</h3>
 * <ul>
 *     <li>二叉搜索树在插入和删除时，节点可能失衡</li>
 *     <li>如果在插入和删除时通过旋转, 始终让二叉搜索树保持平衡, 称为自平衡的二叉搜索树</li>
 *     <li>AVL 是自平衡二叉搜索树的实现之一</li>
 * </ul>
 */
public class AVLTree {

    static class AVLNode {
        int key;
        Object value;
        AVLNode left;
        AVLNode right;
        int height = 1; // 高度

        public AVLNode(int key, Object value) {
            this.key = key;
            this.value = value;
        }

        public AVLNode(int key) {
            this.key = key;
        }

        public AVLNode(int key, Object value, AVLNode left, AVLNode right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

    // 求节点的高度
    private int height(AVLNode node) {
        return node == null ? 0 : node.height;
    }

    // 更新节点高度 (新增、删除、旋转)
    private void updateHeight(AVLNode node) {
        node.height = Integer.max(height(node.left), height(node.right)) + 1;
    }

    // 平衡因子 (balance factor) = 左子树高度-右子树高度  1 -1 0
    private int bf(AVLNode node) {
        return height(node.left) - height(node.right);
    }

    // 参数：要旋转的节点, 返回值：新的根节点
    private AVLNode rightRotate(AVLNode red) {
        AVLNode yellow = red.left;
        AVLNode green = yellow.right;
        yellow.right = red;   // 上位
        red.left = green;     // 换爹
        updateHeight(red);
        updateHeight(yellow);
        return yellow;
    }

    // 参数：要旋转的节点, 返回值：新的根节点
    private AVLNode leftRotate(AVLNode red) {
        AVLNode yellow = red.right;
        AVLNode green = yellow.left;
        yellow.left = red;
        red.right = green;
        updateHeight(red);
        updateHeight(yellow);
        return yellow;
    }

    // 先左旋左子树, 再右旋根节点
    private AVLNode leftRightRotate(AVLNode node) {
        node.left = leftRotate(node.left);
        return rightRotate(node);
    }

    // 先右旋右子树, 再左旋根节点
    private AVLNode rightLeftRotate(AVLNode node) {
        node.right = rightRotate(node.right);
        return leftRotate(node);
    }

    // 检查节点是否失衡, 重新平衡代码
    private AVLNode balance(AVLNode node) {
        if (node == null) {
            return null;
        }
        int bf = bf(node);
        if (bf > 1 && bf(node.left) >= 0) { // LL
            return rightRotate(node);
        } else if (bf > 1 && bf(node.left) < 0) { // LR
            return leftRightRotate(node);
        } else if (bf < -1 && bf(node.right) > 0) { // RL
            return rightLeftRotate(node);
        } else if (bf < -1 && bf(node.right) <= 0) { // RR
            return leftRotate(node);
        }
        return node;
    }

    AVLNode root;

    public void put(int key, Object value) {
        root = doPut(root, key, value);
    }

    private AVLNode doPut(AVLNode node, int key, Object value) {
        // 1. 找到空位, 创建新节点
        if (node == null) {
            return new AVLNode(key, value);
        }
        // 2. key 已存在, 更新
        if (key == node.key) {
            node.value = value;
            return node;
        }
        // 3. 继续查找
        if (key < node.key) {
            node.left = doPut(node.left, key, value); // 向左
        } else {
            node.right = doPut(node.right, key, value); // 向右
        }
        updateHeight(node);
        return balance(node);
    }

    public void remove(int key) {
        root = doRemove(root, key);
    }

    private AVLNode doRemove(AVLNode node, int key) {
        // 1. node == null
        if (node == null) {
            return null;
        }
        // 2. 没找到 key
        if (key < node.key) {
            node.left = doRemove(node.left, key);
        } else if (node.key < key) {
            node.right = doRemove(node.right, key);
        } else {
            // 3. 找到 key  1) 没有孩子 2) 只有一个孩子 3) 有两个孩子
            if (node.left == null) {
                node = node.right;
            } else if (node.right == null) {
                node = node.left;
            } else {
                AVLNode s = node.right;
                while (s.left != null) {
                    s = s.left;
                }
                // s 后继节点
                s.right = doRemove(node.right, s.key);
                s.left = node.left;
                node = s;
            }
        }
        if(node == null){
            return null;
        }
        // 4. 更新高度
        updateHeight(node);
        // 5. balance
        return balance(node);
    }
}

来源

　　数据结构与算法

路漫漫其修远兮，吾将上下而求索。