AVL树(Java实现)

 AVL树基本介绍

AVL树是一种自平衡的二叉查找树，在AVL树中任何节点的两个子树的高度差不能超过1。就是相当于在二叉搜索树的基础上，在插入和删除时进行了平衡处理。

不平衡的四种情况

LL：结构介绍

看如下图，假设最初只有k1, k2, k3, y, z 五个结点，这时该树两边的高度分别为3 和 2，相差为1，满足AVL平衡的概念。

随后插入了结点 x ，导致了不平衡。k1.left.left 有了子树，导致了不平衡。所以是LL结构。

（这个 x 结点是k3的左孩子还是右孩子无所谓,因为无论在左还是在右，处理的方式是通用的）

   

LL：处理

调整的时候发现，k3 和 x 的相对连接关系一直没变，所以x是k3的左孩子还是右孩子无所谓了,都是LL处理方式。x 如果是 k3 的左孩子，处理方式和步骤一模一样。

---> ---> --->

--->--->

LL：代码

    /**
     * @param k1 k1结点的左右两边的高度差2
     * @return 返回LL单转后的新根k2
     */
    private Node leftLeftRotation(Node k1) {
        Node k2 = k1.left;

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

        k1.height = max(height(k1.left), height(k1.right)) + 1;
        k2.height = max(height(k2.left), k1.height) + 1;

        return k2;
    }　　

RR：结构介绍

看如下图，假设最初只有k1, k2, k3, x, y 五个结点，这时该树两边的高度分别为2 和 3，相差为1，满足AVL平衡的概念。

随后插入了结点 z ，导致了不平衡。是 k1.right.right 有了子树，导致了不平衡。所以是RR结构。

（这个 z 结点是k3的左孩子还是右孩子无所谓,因为无论在左还是在右，处理的方式是通用的）

  

RR：处理

 调整的时候发现，k3 和 z 一直没动，所以 z 是 k3 的左孩子还是右孩子无所谓了,都是 RR 处理方式。z 如果是 k3 的左孩子，处理方式和步骤一模一样。

--->--->--->

--->--->

RR：代码

    /**
     * @param k1 k1结点的左右两边的高度差2
     * @return 返回RR单转后的新根k2
     */
    private Node rightRightRotation(Node k1) {
        Node k2 = k1.right;

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

        k1.height = max(height(k1.left), height(k1.right)) + 1;
        k2.height = max(k1.height, height(k2.right)) + 1;

        return k2;
    }　　

LR：结构介绍

看如下图，假设最初只有k1, k2, k3, x, z 五个结点，这时该树两边的高度分别为3 和 2，相差为1，满足AVL平衡的概念。

随后插入了结点 y ，导致了不平衡。是 k1.left.right 有了子树，导致了不平衡。所以是LR结构。

（这个 y 结点是k3的左孩子还是右孩子无所谓,因为无论在左还是在右，处理的方式是通用的）

 

LR：处理

为了后面更方便地描述，我把k3的右孩子 null 空指针画了出来。

现在是LR结构。

先不看k1 和 z 两个结点，把 k1 和 k2 断开连接。把k2为根的子树当成RR结构来进行处理。即先处理这个'R'

--->---> 

如上面最后一张图,经过了RR单转之后，变成了LL结构。对k1为根的树其进行LL单转。如下所示：

--->--->

本次我只演示了当 y 是k3的左孩子时的情况。如果y插入时,是k3的右孩子,那其实就是图片中null结点的地方。转换方式是一模一样。

LR：代码

发现LL 和 RR写好以后，LR虽然复杂，但直接调用这两个方法就行了。很短的。

    /**
     * @param k1 k1结点的左右两边的高度差2
     * @return 返回LR单转后的新根k2
     */
    private Node leftRightRotation(Node k1) {
        k1.left = rightRightRotation(k1.left);
        return leftLeftRotation(k1);
    }　　

RL：结构介绍

看如下图，假设最初只有k1, k2, k3, x, z 五个结点，这时该树两边的高度分别为2 和 3，相差为1，满足AVL平衡的概念。

随后插入了结点 y ，导致了不平衡。是 k1.right.left 有了子树，导致了不平衡。所以是RL结构。

（这个 y 结点是k3的左孩子还是右孩子无所谓,因为无论在左还是在右，处理的方式是通用的）

 

RL：处理

为了后面更方便地描述，我把k3的右孩子 null 空指针画了出来。

 

现在是RL结构。

先不看k1 和 x 两个结点，把 k1 和 k2 断开连接。把k2为根的子树当成LL结构来进行处理。即先处理这个'L'

->->->

如上面最后一张图,经过了RR单转之后，变成了RR结构。对k1为根的树其进行RR单转。如下所示：

   

 本次我只演示了当 y 是k3的左孩子时的情况。如果y插入时,是k3的右孩子,那其实就是图片中null结点的地方。转换方式是一模一样。

RL：代码

    /**
     * @param k1 k1结点的左右两边的高度差2
     * @return 返回RL单转后的新根k2
     */
    private Node rightLeftRotation(Node k1) {
        k1.right = leftLeftRotation(k1.right);
        return rightRightRotation(k1);
    }　　

具体讲解插入导致的不平衡

咱们假设AVL树的初始状态如下，

 随后插入了一个新的结点7。7与根进行比较，发现7<50，所以去左子树查找。

7继续进行比较，7<30，所以继续去左子树查找。

重复这些步骤，在代码里是用递归处理的。直到找到7为止，或者遍历到叶子节点了也没找到7为止。

没找到7...因为7比15小，所以7插入在15左侧。这时以k1为根的树不平衡了！！！

问：我能用眼睛看出来，但程序怎么算呢？   答：height(k1.left) - height(k1.right) == 2 了。

问：为什么是左子树高度 减 右子树高度？   答：因为...之前是平衡的，在左侧插入后就不平衡了。肯定是左侧大啊。

问：嗯，左子树高度比右子树大说明啥？   答：说明...肯定是 k1 左边。也就是LL结构或者是LR结构,第一个字母 ‘L’ 已经确定了。

问：那剩下的你怎么确定是LL还是LR ？  答：很简单，新节点比k2小，那就是LL；新节点比k2大，那就是LR。继续往下看图：

---确定了LL结构---> 

问：LL结构挺好理解，判断LR会不会很麻烦啊？ 答：方法一模一样...没多没少...咱们假设一开始插入的不是7，而是35，那么如下图所示：

---确定LR--->

问：为什么不介绍RR和RL了？ 答：LL、LR都会了，RR、RL其实就是一码事了。不再重复演示了.....（画图好累....）

具体讲解删除导致的不平衡

讲删除导致不平衡之前，先讲讲到底怎么在AVL树中删除一个结点。

假设删除前的树如下图所示，想要删除 90 结点：

问：怎么删除呢？ 答：先从树根定位到 90 结点。

问：怎么定位呢？  答：利用递归，与当前子树根进行比较。小，去左边找；大，去右边找；等于，就找到了。

问：找到之后就可以直接删了吗？ 答：还得考虑要删除的那个结点是否还有孩子。分为如下三种情况：

情况1：   90结点没有左孩子

没有左孩子的话，把70结点的right 连上 90结点的right。没有左孩子不代表一定有右孩子。如果90的right是null的话，那就把这个null赋给70的right就好了。

->->

 情况2：   90结点没有右孩子

没有右孩子的话，把 70结点的right 连上 90结点的left。

->->

情况3：   90结点既有左孩子又有右孩子

如果要删除的 90 结点情况如下，那么需要在删除前找到 90 结点的 前驱结点 或者 后继结点。如下面的第一张图。

问：找 前驱结点 / 后继结点 干嘛呢？ 答：90的前驱和后继结点是最接近90的两个结点。用他们俩替换掉90，就相当于删掉了90。如下面的第二张图。

问：第二张图我看完了，你选用90的后继结点93替换了90，之后树中不就有两个93了吗？ 答：删掉原来的93就好了

问：原来的93怎么删？ 答：去新的93的右子树里找原来的93，并且删除。咱们现在介绍的是情况3(被删除的结点有左右孩子)，而且93是后继结点，肯定不会有左孩子，所以删除原来的93的问题，就回到了情况1。

一句概括就是：在新93结点的右子树中删除原93。（见下面第3张图）

问：你图中演示的是后继结点93来替换90，那前驱结点呢？ 答：刚才说了后继结点肯定没有左孩子，而前驱结点肯定没有右孩子。用前驱80结点来替换90之后，再去删除原来的80，而这个80肯定没有右孩子，所以就回到了情况2。

一句话概括就是：如果用前驱80替换90，再删除原来的80，就回到了情况2；如果用后继93替换90，再删除原来的93，就回到了情况1。

看起来选前驱和选后继没什么两样，但是，如果90结点的右子树深，最好用后继来替换；如果90结点的左子树深，最好用前驱来替换。

->->

问：前驱和后继怎么求呢？ 答： 首先要会求树中的最大、最小结点。从根开始向左遍历，到头了，那么这个最左边的叶子节点就是最小值。同理，一直向右遍历就是最大值。

问：那么最大最小值跟前驱后继什么关系呢？ 答：咱们以情况3的第一张图片为例。找50的前驱怎么找呢，就是50结点的左子树中的最大值。后继结点呢，就是50结点的右子树中的最小值。

问：还是不懂，给我看看代码？ 

答：

    private Node minNode(Node node) {
        if (node == null) {
            return null;
        } else if (node.left == null) {
            return node;
        } else {
            return minNode(node.left);
        }
    }
--------------------------------------------------------
Node successor = minNode(node.right);//找node的后继结点successor

　　

如何删除一个结点已经讲完了。

下面看看删除一个结点后都会遇到什么不平衡的情况。

假设删除前的树如下图所示，想要删除 90 结点：

删除值为90的结点后，高度差为2，不满足AVL定义。

 

因为是删除了50 (k1) 右子树中的结点后导致的不平衡，所以肯定是左子树太深导致了不平衡。

第一个字母‘L’已经确定，所以是 LL 和 LR 结构之一。

需要判断 k2 的左右两子树，左边深，那就是LL；右边深，那就是LR。

 ---确定LL结构--->

 如果k2的左右两子树高度相等...那就LL/LR随意了...主要目的就是处理掉高的那部分。

AVL树完整代码

public class AVLTree<Key extends Comparable<? super Key>, Value> {
    private class Node {
        Key key;//键，相当于词典里的单词
        Value value;//值，相当于词典里的单词解释
        int height;//结点的高度
        Node left;
        Node right;

        public Node(Key key, Value value) {
            this.key = key;
            this.value = value;
            this.left = null;
            this.right = null;
            int height = 1;
        }
    }

    private Node root;

    public AVLTree() {
        root = null;
    }

    private int height(Node node) {
        if (node != null) {
            return node.height;
        }
        return 0;
    }

    public int height() {
        return height(root);
    }

    private int max(int a, int b) {
        return a > b ? a : b;
    }

    private void replaceNode(Node src, Node tar) {
        tar.key = src.key;
        tar.value = src.value;
    }

    private void preOrder(Node node) {
        if (node != null) {
            System.out.println(node.key);
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    public void preOrder() {
        preOrder(root);
    }

    private void inOrder(Node node) {
        if (node != null) {
            inOrder(node.left);
            System.out.println(node.key);
            inOrder(node.right);
        }
    }

    public void inOrder() {
        inOrder(root);
    }

    public void postOrder(Node node) {
        if (node != null) {
            postOrder(node.left);
            postOrder(node.right);
            System.out.println(node.key);
        }
    }

    public void postOrder() {
        postOrder(root);
    }

    private Node search(Node node, Key key) {
        if (node == null) {
            return null;
        } else if (key.compareTo(node.key) == 0) {
            return node;
        } else if (key.compareTo(node.key) < 0) {
            return search(node.left, key);
        } else {//key.compareTo(node.key) > 0
            return search(node.right, key);
        }
    }

    public Node search(Key key) {
        return search(root, key);
    }

    private Node minNode(Node node) {
        if (node == null) {
            return null;
        } else if (node.left == null) {
            return node;
        } else {
            return minNode(node.left);
        }
    }

    public Node minNode() {
        return minNode(root);
    }

    private Node maxNode(Node node) {
        if (node == null) {
            return null;
        } else if (node.right == null) {
            return node;
        } else {
            return maxNode(node.right);
        }
    }

    public Node maxNode() {
        return maxNode(root);
    }

    // 对如下的LL情况
    //
    //         k1                 k2
    //        /  \               /  \
    //       k2   z    LL单转   x    k1
    //      /  \       ----\   /    / \
    //     x    y      ----/  o    y   z
    //    //    /      k1右旋
    //   o
    //
    //   或
    //
    //         k1                 k2
    //        /  \               /  \
    //       k2   z    LL单转    x   k1
    //      /  \       ----\     \  / \
    //     x    y      ----/      o y  z
    //      \          k1右旋
    //       o
    //
    private Node leftLeftRotation(Node k1) {
        Node k2 = k1.left; //k2是k1的左子树

        k1.left = k2.right;//k2的右子树 变为 k1 的左子树
        k2.right = k1; //k1变为k2的右子树

        k1.height = max(height(k1.left), height(k1.right)) + 1;//计算k1的高度
        k2.height = max(height(k2.left), k1.height) + 1;//计算k2的高度

        return k2;//返回新的根k2
    }


    // 对如下的RR情况
    //
    //         k1                      k2
    //        /  \                    /  \
    //       x    k2      RR单转     k1   k3
    //           / \      ----\     / \    \
    //          y   k3    ----/    x   y    z
    //               \    k1左旋
    //                z
    //
    //   或
    //
    //         k1                      k2
    //        /  \                    /  \
    //       x    k2      RR单转       k1   k3
    //           / \      ----\     / \   /
    //          y  k3     ----/    x   y z
    //             /      k1左旋
    //            z
    //
    public Node rightRightRotation(Node k1) {
        Node k2 = k1.right;

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

        k1.height = max(height(k1.left), height(k1.right)) + 1;
        k2.height = max(k1.height, height(k2.right)) + 1;

        return k2;
    }

    // 对如下的LR情况
    //      k1                k1                k3
    //     /  \              /  \              /  \
    //    k2   z  RR单转    k3   z   LL单转    k2  k1
    //   /  \     -----\   / \      -----\   / \  / \
    //  w   k3    -----/  k2  y     -----/  w  x y   z
    //     /  \   k2左旋  / \        k1右旋
    //    x    y         w  x
    //
    public Node leftRightRotation(Node k1) {
        k1.left = rightRightRotation(k1.left);
        return leftLeftRotation(k1);
    }

    // 对如下的RL情况
    //    k1                k1                  k3
    //   /  \     LL单转    / \      RR单旋     /  \
    //  w   k2    -----\   w  k3    -----\    k1  k2
    //      / \   -----/     / \    -----/   / \  / \
    //     k3  z  k2右旋     x  k2   k1左旋  w   x y  z
    //    / \                  / \
    //   x   y                y   z
    //
    public Node rightLeftRotation(Node k1) {
        k1.right = leftLeftRotation(k1.right);
        return rightRightRotation(k1);
    }

    //插入
    private Node insert(Node node, Key key, Value value) {
        if (node == null) return new Node(key, value);

        if (key.compareTo(node.key) == 0) {//如果key相同则更新该节点

            node.value = value;

        } else if (key.compareTo(node.key) < 0) {//如果key比当前根小，则去左子树找。即一步Left

            node.left = insert(node.left, key, value);
            if (height(node.left) - height(node.right) == 2) {//插在左边所以肯定是左-右，高度差2表示已经不平衡
                if (key.compareTo(node.left.key) < 0) {// 又一步Left，所以是LeftLeft
                    node = leftLeftRotation(node);
                } else { //一步Right，所以是LeftRight
                    node = leftRightRotation(node);
                }
            }

        } else {   // node.key < key,那么去右子树找.即一步Right

            node.right = insert(node.right, key, value);
            if (height(node.right) - height(node.left) == 2) {//插在右边所以肯定是右-左，高度差2表示已经不平衡
                if (key.compareTo(node.right.key) > 0) {//又一步Right,所以是RightRight
                    node = rightRightRotation(node);
                } else {//一步Left，所以是RightLeft
                    node = rightLeftRotation(node);
                }
            }

        }

        node.height = max(height(node.left), height(node.right)) + 1;
        return node;
    }

    public void insert(Key key, Value value) {
        this.root = insert(this.root, key, value);
    }

    //删除

    /**
     * @param node   当前子树根节点
     * @param target 要删除的结点
     * @return 删除后的新的子树根
     */
    public Node remove(Node node, Node target) {
        if (node == null || target == null) return node;

        if (target.key.compareTo(node.key) < 0) {//待删除key的比根的key小，那么继续在左子树查找

            node.left = remove(node.left, target);
            if (height(node.right) - height(node.left) == 2) {//如果在删除后失去平衡
                if (height(node.right.left) <= height(node.right.right)) {
                    node = rightRightRotation(node);
                } else {
                    node = rightLeftRotation(node);
                }
            }

        } else if (node.key.compareTo(target.key) < 0) {//待删除key的比根的key大，那么继续在右子树查找

            node.right = remove(node.right, target);
            if (height(node.left) - height(node.right) == 2) {
                if (height(node.left.right) <= height(node.left.left)) {
                    node = leftLeftRotation(node);
                } else {
                    node = rightRightRotation(node);
                }
            }

        } else { // node.key == target.key
            if (node.left == null) { // 如果node的左子树为空，那么删除node后，新的根就是node.right
                return node.right;
            } else if (node.right == null) {// 如果node的右子树为空，那么删除node后，新的根就是node.left
                return node.left;
            } else { // 如果node既有左子树，又有右子树

                if (height(node.left) > height(node.right)) {//如果左子树比右子树深
                    Node predecessor = maxNode(node.left);//找node的前继结点predecessor
                    replaceNode(predecessor, node);//predecessor替换node
                    node.left = remove(node.left, predecessor);//再把原来的predecessor删掉
                } else {//如果右子树比左子树深(一样深的话无所谓了)
                    Node successor = minNode(node.right);//找node的后继结点successor
                    replaceNode(successor, node);//successor替换node
                    node.right = remove(node.right, successor);//再把原来的successor删掉
                }

            }
        }
        return node;
    }

    public void remove(Key key) {
        Node z;
        if ((z = search(root, key)) != null)
            root = remove(root, z);
    }

    private void destroy(Node node) {
        if (node == null)
            return;

        if (node.left != null)
            destroy(node.left);
        if (node.right != null)
            destroy(node.right);

        node = null;
    }

    public void destroy() {
        destroy(root);
        System.out.println("销毁完毕");
    }

    private void print(Node tree, Key key, String pos) {
        if (tree != null) {
            if (pos.equals(""))    // tree是根节点
                System.out.printf("%2d is root\n", tree.key);
            else                // tree是分支节点
                System.out.printf("%2d is %2d's %6s child\n", tree.key, key, pos);

            print(tree.left, tree.key, "left");
            print(tree.right, tree.key, "right");
        }
    }

    public void print() {
        if (root != null) print(root, root.key, "");
    }

    //***************************************************************
    private static int arr[] = {3, 2, 1, 4, 5, 6, 7, 16, 15, 14, 13, 12, 11, 10, 8, 9};

    public static void main(String[] args) {
        int i;
        AVLTree<Integer, Integer> tree = new AVLTree<>();

        System.out.printf("*******依次添加: ");
        for (i = 0; i < arr.length; i++) {
            System.out.printf("%d ", arr[i]);
            tree.insert(arr[i], arr[i]);
        }
        System.out.println();


        System.out.print("*******前序遍历: ");
        tree.preOrder();
        System.out.println();


        System.out.print("*******中序遍历: ");
        tree.inOrder();
        System.out.println();


        System.out.print("*******后序遍历: ");
        tree.postOrder();
        System.out.println();


        System.out.println("*******高度:" + tree.height());
        System.out.println("*******最小值:" + tree.minNode().key);
        System.out.println("*******最大值:" + tree.maxNode().key);
        System.out.println("*******树的详细信息:");
        tree.print();
        System.out.println();


        i = 8;
        System.out.printf("*******删除根节点: %d", i);
        tree.remove(i);
        System.out.println();


        System.out.println("*******高度:" + tree.height());
        System.out.println("*******中序遍历: ");
        tree.inOrder();
        System.out.println();



        System.out.println("*******树的详细信息:");
        tree.print();
        System.out.println();

        // 销毁二叉树
        tree.destroy();
    }
}