数据结构-AVL(自平衡二叉查找树)插入和删除的实现

一. AVL的作用

为什么使用AVL?

在使用二分搜索树的时候，在极端的情况下，会退化成链表。如下图

二. AVL的特点

• 对于任意一个节点，左子树和右子树的高度差不能超过1。
• 高度和节点数量之间的关系也是O(logn)的。
• 加入/删除节点后，沿着节点维护平衡性。
• 

三. 如何维护AVL的平衡

1. 添加 如何维护平衡（4种情景）

情景1 ： 左子树的左节点上（LL）: 右旋转。

右旋转伪代码：

//右旋转
//        y                              x
//     /    \                         /    \
//    x     T4   向右选择（y）         z      y
//   / \             ---->          /  \    / \
//  z  T3                           1  T2  T3 T4
// / \
//T1 T2
// T1 < z < T2 < x < T3 < y < T4
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;
} 

情景2 ： 右子树的右节点上（RR）：左旋转

左旋转伪代码：

 //左旋转
    //        y                              x
    //     /    \                         /    \
    //    T1     x        向左选择（y）    y      z
    //          / \      ---->          /  \    / \
    //         T2  z                    T1  T2 T3 T4
    //            / \
    //           T3 T4
    // T1 < y < T2 < x < T3 < z < T4
    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;
    }

情景3 ： 左子树的右节点上（LR）：左子节点 左旋转， 然后右旋转

情景4 ： 右子树的左节点上（RL）：右子节点 右旋转， 然后左旋转

2. 删除如何维护平衡？

删除以10为根节点的元素9.返回新的根节点。

逻辑
1 ： 判断根节点是否为null,如果为null，返回null。
2： 判断待删除的节点和根节点比较，如果比根节点小，就从根节点的左子树中删除，返回原来的根节点。
node.left = remove(node.left,key).递归调用。
如果比根节点大，就从右子树中删除，返回原来的根节点。
node.right = remove(node.right,key),递归调用。
如果和根节点相同，则删除根节点，删除根节点：首先判断左子树是否为空，如果为空，则新的根节点为原来根节点的右子树。
if(node.left ==null){
Node rightNode = node.right;
node.right = null;
size–;
retNode = rightNode;
}
如果右子树为空，则新的根节点为原来根节点的左子树。
if(node.right == null){
Node leftNode = node.left;
node.left = null;
size–;
retNode = leftNode;
}
如果左右子树都不为空，则查询出右子树中最小的元素作为新的根节点。然后删除右子树的最小根节点，最后保持之前树的结构
Node successor = minimum(node.right)；
successor.right = remove(mode.right,key);
successor.left = node.left;
node.left = mode.right = null;
retNode = successor;

以上的删除的操作，下面是维护平衡的操作。
3: 返回删除后的根节点是否为null，如果为null,返回null.
4: 更新返回根节点的高度，然后计算平衡因子，判断高度差是否大于1。如果大于1，则维护平衡。
四种情况：1.如果左H-右H > 1 且左子树的平衡因子>=0,即LL,右旋。
2.如果右H-左H > 1 且右子树的平衡因子<=0,即RR,左旋。
3. 如果右H-左H > 1 ，RL，先右旋变成RR,然后左旋。
4.如果左H-右H >1 ,LR，先左旋，变成LL,然后右旋。
返回待删除的节点。

删除的伪代码如下：

/**
 * 删除以Node为根节点的key ,返回新根节点
 *
 * @param node
 * @param key
 * @return
 */
private Node remove(Node node, K key) {
    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.right = remove(node.right, successor.key);
            successor.left = node.left;
            node.left = node.right = null;
            retNode = successor;
        }
    }

    //删除后的根为空
    if (retNode == null) {
        return null;
    }
    //更新height 左子树的高度和右子树最大的+1
    retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));
    //计算平衡因子
    int balanceFactor = getBalanceFactor(retNode);
    //平衡二叉树
    if (Math.abs(balanceFactor) > 1) {
        System.out.println("unbalanced: " + balanceFactor);
        //维护平衡性
    }

    //平衡维护   左子树的高度大于等于右子树的高度 向左倾斜 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;
}

四. 时间复杂度分析

• 删除 O(logN)
• 插入O(logN)
• 查询O(logN)

五. Java代码的简单实现

import java.util.ArrayList;

/**
 * 平衡二叉树 ：对于任意一个节点，左子树和右子树的高度差不能超过1.
 * 平衡二叉树的高度和节点数量之间的关系也是O(logn)的。
 * 标注节点的高度
 * 计算平衡因子： 左右子树的高度差 大于1的就不是平衡二叉树
 * <p>
 * 下面是按照二分搜索树 实现的AVL
 * <p>
 * 在加入节点后，沿着节点向上维护平衡性
 * <p>
 * AVL树的左旋转和右旋转
 * LL 左子树的左侧 右旋转
 * RR 右子树的右侧 左旋转
 * LR Y左子树的右侧 左子树X的根节点左旋转变成了LL的情况，在对Y进行右旋转。
 * RL Y右子树的左侧 右子树X的根节点右旋转变成了RR的情况，在对Y进行左旋转。
 * <p>
 * AVL的删除 依然考虑到什么时候维护平衡。
 * <p>
 * 更多AVL树的相关问题
 * <p>
 * AVL的优化 -> 维护平衡 高度和之前一样，就不需要去维护了
 * AVL树的局限性：红黑树的平均性能比AVL好些。都是O(logN)
 * 维护不平衡的二分搜索树
 *
 * @author 一直往前走
 * @date 2020/03/25
 */
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;
            this.left = null;
            this.right = null;
            this.height = 1;//新的节点高度都是1 就是叶子节点的高度。
        }
    }

    private Node root;

    private int size;

    public AVLTree() {
        root = null;
        size = 0;
    }

    //获得节点的高度
    private int getHeight(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }


    /**
     * 向二分搜索树添加新的元素（key,value)
     *
     * @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) {
        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 {
            node.value = value;
        }
        //更新height 左子树的高度和右子树最大的+1
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
        //计算平衡因子 节点node 左右子树的高度查
        int balanceFactor = getBalanceFactor(node);
        //平衡二叉树
        if (Math.abs(balanceFactor) > 1) {
            System.out.println("unbalanced: " + balanceFactor);
            //维护平衡性
        }

        //平衡维护   左子树的高度大于等于右子树的高度 向左倾斜 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) {
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }

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

        return node;
    }

    //右旋转
    //        y                              x
    //     /    \                         /    \
    //    x     T4   向右选择（y）         z      y
    //   / \             ---->          /  \    / \
    //  z  T3                           1  T2  T3 T4
    // / \
    //T1 T2
    // T1 < z < T2 < x < T3 < y < T4
    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;
    }


    //左旋转
    //        y                              x
    //     /    \                         /    \
    //    T1     x        向左选择（y）    y      z
    //          / \      ---->          /  \    / \
    //         T2  z                    T1  T2 T3 T4
    //            / \
    //           T3 T4
    // T1 < y < T2 < x < T3 < z < T4
    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;
    }

    //获得节点Node的平衡因子
    private int getBalanceFactor(Node node) {
        if (node == null) {
            return 0;
        }
        return getHeight(node.left) - getHeight(node.right);
    }

    //判断该二叉树是否是一棵二分搜索树
    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;
    }

    //判断是否是一棵平衡二叉树
    public boolean isBalanced() {
        return isBalanced(root);
    }

    //判断以Node为根的二叉树是否是一棵平衡二叉树，递归算法
    public boolean isBalanced(Node node) {
        //节点为空，肯定是平衡的
        if (node == null) {
            return true;
        }
        //平衡因子
        int balancedFactor = getBalanceFactor(node);
        //平衡因子绝对值不能大于1
        if (Math.abs(balancedFactor) > 1) {
            return false;
        }
        //左子树和右子树是否都是平衡二叉树
        return isBalanced(node.left) && isBalanced(node.right);
    }


    private void inOrder(Node node, ArrayList<K> keys) {
        if (node == null) {
            return;
        }
        //中序便利
        inOrder(node.left, keys);
        keys.add(node.key);
        inOrder(node.right, keys);
    }

    /**
     * 返回以node为根节点的二分搜索树中，key所在的节点
     *
     * @param node
     * @param key
     * @return
     */
    private Node getNode(Node node, K key) {
        if (node == null) {
            return null;
        }

        if (key.compareTo(node.key) == 0) {
            return node;
        } else if (key.compareTo(node.key) < 0) {
            return getNode(node.left, key);
        } else {
            return getNode(node.right, key);
        }
    }

    /**
     * 删除以Node为根节点的key ,返回新根节点
     *
     * @param node
     * @param key
     * @return
     */
    private Node remove(Node node, K key) {
        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.right = remove(node.right, successor.key);
                successor.left = node.left;
                node.left = node.right = null;
                retNode = successor;
            }
        }

        //删除后的根为空
        if (retNode == null) {
            return null;
        }
        //更新height 左子树的高度和右子树最大的+1
        retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));
        //计算平衡因子
        int balanceFactor = getBalanceFactor(retNode);
        //平衡二叉树
        if (Math.abs(balanceFactor) > 1) {
            System.out.println("unbalanced: " + balanceFactor);
            //维护平衡性
        }

        //平衡维护   左子树的高度大于等于右子树的高度 向左倾斜 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;
    }

    /**
     * 删除以node为根的二分搜索树
     * 返回二分搜索树的根
     * 添加平衡维护 或者
     *
     * @param node
     * @return
     */
    private Node removeMin(Node node) {
        //如果左节点为null,原根的右节点作为根节点。
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }


    public V remove(K key) {
        //todo 仿照BST  自己写
        return null;
    }

    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) {
        AVLTree.Node node = getNode(root, key);
        if (node == null) {
            throw new IllegalArgumentException(key + "doesn't exist~");
        }
        node.value = newValue;
    }


    /**
     * 查找二分查找树的最小元素
     *
     * @return
     */
    public V minimum() {
        if (size == 0) {
            throw new IllegalArgumentException("BST is empty!");
        }
        return minimum(root).value;
    }

    /**
     * 最小值以node为根的二分搜索树
     *
     * @param node
     * @return
     */
    private Node minimum(AVLTree.Node node) {
        if (node.left == null) {
            return node;
        }
        return minimum(node.left);
    }

    /**
     * 查找二分查找树的最大元素
     *
     * @return
     */
    public V maximum() {
        if (size == 0) {
            throw new IllegalArgumentException("BST is empty!");
        }
        return maximum(root).value;
    }

    /**
     * 最大值以node为根的二分搜索树
     *
     * @param node
     * @return
     */
    private Node maximum(AVLTree.Node node) {
        if (node.right == null) {
            return node;
        }
        return minimum(node.right);
    }


    public int getSize() {
        return size;
    }

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

    public static void main(String[] args) {

    }
}