Java數據結構與算法解析(六)——AVL樹">Java數據結構與算法解析(六)——AVL樹

之前我們說過普通二叉查找樹的刪除算法會使得左子樹比右子樹深，因為我們總是用右子樹的一個來代替刪除的節點。會造成二叉查找樹，嚴重的不平衡。

AVL樹簡介

而AVL樹就是解決普通二叉查找樹弊端的方法，他是帶有平衡條件的二叉查找樹，這個平衡條件必須容易保持，而且它保證樹的深度必須是O(logN).

AVL樹是高度平衡的而二叉樹。它的特點是：AVL樹中任何節點的兩個子樹的高度最大差別為1。

上面的兩張圖片，左邊的是AVL樹，它的任何節點的兩個子樹的高度差別都<=1；而右邊的不是AVL樹，因為7的兩顆子樹的高度相差為2(以2為根節點的樹的高度是3，而以8為根節點的樹的高度是1)。

AVL樹的實現

1.節點

// AVL樹的節點(內部類)
    class AVLTreeNode<T extends Comparable<T>> {
        T element;                // 值
        int height;         // 高度
        AVLTreeNode<T> left;    // 左孩子
        AVLTreeNode<T> right;    // 右孩子

        public AVLTreeNode(T key, AVLTreeNode<T> left, AVLTreeNode<T> right) {
            this.element = key;
            this.left = left;
            this.right = right;
            this.height = 0;
        }
    }

AVLTree是AVL樹對應的類，而AVLTreeNode是AVL樹節點，它是AVLTree的內部類。AVLTree包含了AVL樹的根節點，AVL樹的基本操作也定義在AVL樹中。AVLTreeNode包括的幾個組成對象:

(1) key – 是關鍵字，是用來對AVL樹的節點進行排序的。

(2) left – 是左孩子。

(3) right – 是右孩子。

(4) height – 是高度。

2.樹的高度

/*
 * 獲取樹的高度
 */
private int height(AVLTreeNode<T> tree) {
    if (tree != null)
        return tree.height;

    return 0;
}

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

有的地方將”空二叉樹的高度是-1”，這裏我們采用另一種定義：樹的高度為最大層次。即空的二叉樹的高度是0，非空樹的高度等於它的最大層次(根的層次為1，根的子節點為第2層，依次類推)。

3.旋轉

如果在AVL樹中進行插入或刪除節點後，可能導致AVL樹失去平衡。這種失去平衡的可以概括為4種姿態：LL(左左)，LR(左右)，RR(右右)和RL(右左)。

上圖中的4棵樹都是”失去平衡的AVL樹”，從左往右的情況依次是：LL、LR、RL、RR。除了上面的情況之外，還有其它的失去平衡的AVL樹，如下圖：

(1)LL：LeftLeft，也稱為”左左”。插入或刪除一個節點後，根節點的左子樹的左子樹還有非空子節點，導致”根的左子樹的高度”比”根的右子樹的高度”大2，導致AVL樹失去了平衡。

例如，在上面LL情況中，由於”根節點(8)的左子樹(4)的左子樹(2)還有非空子節點”，而”根節點(8)的右子樹(12)沒有子節點”；導致”根節點(8)的左子樹(4)高度”比”根節點(8)的右子樹(12)”高2。

(2)LR：LeftRight，也稱為”左右”。插入或刪除一個節點後，根節點的左子樹的右子樹還有非空子節點，導致”根的左子樹的高度”比”根的右子樹的高度”大2，導致AVL樹失去了平衡。

例如，在上面LR情況中，由於”根節點(8)的左子樹(4)的左子樹(6)還有非空子節點”，而”根節點(8)的右子樹(12)沒有子節點”；導致”根節點(8)的左子樹(4)高度”比”根節點(8)的右子樹(12)”高2。

(3)RL：RightLeft，稱為”右左”。插入或刪除一個節點後，根節點的右子樹的左子樹還有非空子節點，導致”根的右子樹的高度”比”根的左子樹的高度”大2，導致AVL樹失去了平衡。

例如，在上面RL情況中，由於”根節點(8)的右子樹(12)的左子樹(10)還有非空子節點”，而”根節點(8)的左子樹(4)沒有子節點”；導致”根節點(8)的右子樹(12)高度”比”根節點(8)的左子樹(4)”高2。

(4)RR：RightRight，稱為”右右”。插入或刪除一個節點後，根節點的右子樹的右子樹還有非空子節點，導致”根的右子樹的高度”比”根的左子樹的高度”大2，導致AVL樹失去了平衡。

例如，在上面RR情況中，由於”根節點(8)的右子樹(12)的右子樹(14)還有非空子節點”，而”根節點(8)的左子樹(4)沒有子節點”；導致”根節點(8)的右子樹(12)高度”比”根節點(8)的左子樹(4)”高2。

如果在AVL樹中進行插入或刪除節點後，可能導致AVL樹失去平衡。AVL失去平衡之後，可以通過旋轉使其恢復平衡，下面分別介紹”LL(左左)，LR(左右)，RR(右右)和RL(右左)”這4種情況對應的旋轉方法。

LL的旋轉

LL失去平衡的情況，可以通過一次旋轉讓AVL樹恢復平衡。如下圖：

圖中左邊是旋轉之前的樹，右邊是旋轉之後的樹。從中可以發現，旋轉之後的樹又變成了AVL樹，而且該旋轉只需要一次即可完成。

對於LL旋轉，你可以這樣理解為：LL旋轉是圍繞”失去平衡的AVL根節點”進行的，也就是節點k2；而且由於是LL情況，即左左情況，就用手抓著”左孩子，即k1”使勁搖。將k1變成根節點，k2變成k1的右子樹，”k1的右子樹”變成”k2的左子樹”。

LL的旋轉代碼

/**
     * LL：左左對應的情況(左單旋轉)。
     * @param k2
     * @return 旋轉後的根節點
     */
    private AVLTreeNode<T> leftLeftRotation(AVLTreeNode<T> k2) {
        AVLTreeNode<T> k1;

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

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

        return k1;
    }

RR的旋轉

理解了LL之後，RR就相當容易理解了。RR是與LL對稱的情況！RR恢復平衡的旋轉方法如下：

圖中左邊是旋轉之前的樹，右邊是旋轉之後的樹。RR旋轉也只需要一次即可完成。

private AVLTreeNode<T> rightRightRotation(AVLTreeNode<T> k1) {
        AVLTreeNode<T> k2;

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

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

        return k2;
    }

LR的旋轉

LR失去平衡的情況，需要經過兩次旋轉才能讓AVL樹恢復平衡。

第一次旋轉是圍繞”k1”進行的”RR旋轉”，第二次是圍繞”k3”進行的”LL旋轉”。

LR的旋轉代碼

/**
     *  LR：左右對應的情況(左雙旋轉)。
     * @param k3
     * @return 旋轉後的根節點
     */
    private AVLTreeNode<T> leftRightRotation(AVLTreeNode<T> k3) {
        k3.left = rightRightRotation(k3.left);

        return leftLeftRotation(k3);
    }

RL的旋轉

RL是與LR的對稱情況！RL恢復平衡的旋轉方法如下：

第一次旋轉是圍繞”k3”進行的”LL旋轉”，第二次是圍繞”k1”進行的”RR旋轉”。

RL的旋轉代碼

/**
     * RL：右左對應的情況(右雙旋轉)。
     * @param k1
     * @return 旋轉後的根節點
     */
    private AVLTreeNode<T> rightLeftRotation(AVLTreeNode<T> k1) {
        k1.right = leftLeftRotation(k1.right);

        return rightRightRotation(k1);
    }

4.插入

public void insert(T key) {
        mRoot = insert(mRoot, key);
    }

    /**
     * 將結點插入到AVL樹中，並返回根節點
     *
     * @param tree AVL樹的根結點
     * @param key  插入的結點的鍵值
     * @return 根節點
     */
    private AVLTreeNode<T> insert(AVLTreeNode<T> tree, T key) {
        if (tree == null) {
            // 新建節點
            return tree = new AVLTreeNode<T>(key, null, null);

        }

        int cmp = key.compareTo(tree.element);
        if (cmp < 0) {// 將key插入到"tree的左子樹"的情況
            tree.left = insert(tree.left, key);

        } else if (cmp > 0) { // 將key插入到"tree的右子樹"的情況
            tree.right = insert(tree.right, key);
        }

        return balance(tree);
    }

插入節點後，可能會使AVL樹失去平衡，通過balance()方法進行相應的調節。

private static final int ALLOWED_IMBALANCE = 1;

    private AVLTreeNode<T> balance(AVLTreeNode<T> tree) {
        if (tree == null) {
            return tree;
        }
        // 插入節點後，若AVL樹失去平衡，則進行相應的調節。
        if (height(tree.left) - height(tree.right) > ALLOWED_IMBALANCE) {

            if (height(tree.left.left) >= height(tree.left.right)) {
                leftLeftRotation(tree);
            } else {
                leftRightRotation(tree);
            }
        } else if (height(tree.right) - height(tree.left) > ALLOWED_IMBALANCE) {
            if (height(tree.right.right) >= height(tree.right.left)) {
                rightRightRotation(tree);
            } else {
                rightLeftRotation(tree);
            }
        }
        tree.height = Math.max( height(tree.left), height(tree.right)) + 1;

        return tree;
    }

5.刪除

public void remove(T key) {
        AVLTreeNode<T> z;

        mRoot = remove(mRoot, z);
    }

    /**
     * 刪除結點(z)，返回根節點
     *
     * @param tree AVL樹的根結點
     * @param z    待刪除的結點
     * @return 根節點
     */
    private AVLTreeNode<T> remove(AVLTreeNode<T> tree, AVLTreeNode<T> z) {
        if (tree == null)
            return tree;

        int cmp = z.element.compareTo(tree.element);
        if (cmp > 0) {
            tree.right = remove(tree.right, z);
        } else if (cmp < 0) {
            tree.left = remove(tree.left, z);
        } else if (tree.left != null && tree.right != null) {
            tree.element = findMin(tree.right).element;
            tree.right = remove(tree.element, tree.right);
        } else {
            tree = (tree.left != null) ? tree.left : tree.right;
        }
        return balance(tree);
    }

    private AVLTreeNode<T> findMin(AVLTreeNode<T> node) {
        if (node != null) {
            while (node.left != null) {
                node = node.left;
            }
        }
        return node;
    }

    public AVLTreeNode<T> remove(T t, AVLTreeNode<T> node) {
        if (node == null) {
            return node;
        }
        int compareResult = t.compareTo(node.element);
        if (compareResult > 0) {
            node.right = remove(t, node.right);
        } else if (compareResult < 0) {
            node.left = remove(t, node.left);
        } else if (node.left != null && node.right != null) {
            node.element = findMin(node.right).element;
            node.right = remove(node.element, node.right);
        } else {
            node = (node.left != null) ? node.left : node.right;
        }
        return node;

    }

刪除操作就是在原來查找二叉樹的基礎上，每一次刪除都調用balance()方法對AVL樹進行再平衡。

完整的實現代碼如下：

public class AVLTree<T extends Comparable<T>> {

    private AVLTreeNode<T> mRoot;    // 根結點

    // AVL樹的節點(內部類)
    class AVLTreeNode<T extends Comparable<T>> {
        T element;                // 值
        int height;         // 高度
        AVLTreeNode<T> left;    // 左孩子
        AVLTreeNode<T> right;    // 右孩子

        public AVLTreeNode(T key, AVLTreeNode<T> left, AVLTreeNode<T> right) {
            this.element = key;
            this.left = left;
            this.right = right;
            this.height = 0;
        }
    }

    /*
 * 獲取樹的高度
 */
    private int height(AVLTreeNode<T> tree) {
        if (tree != null)
            return tree.height;

        return 0;
    }

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

    /*
 * LL：左左對應的情況(左單旋轉)。
 *
 * 返回值：旋轉後的根節點
 */

    /**
     * LL：左左對應的情況(左單旋轉)。
     *
     * @param k2
     * @return 旋轉後的根節點
     */
    private AVLTreeNode<T> leftLeftRotation(AVLTreeNode<T> k2) {
        AVLTreeNode<T> k1;

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

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

        return k1;
    }

    /**
     * 右右對應的情況(右單旋轉)。
     *
     * @param k1
     * @return 旋轉後的根節點
     */
    private AVLTreeNode<T> rightRightRotation(AVLTreeNode<T> k1) {
        AVLTreeNode<T> k2;

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

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

        return k2;
    }


    /**
     * LR：左右對應的情況(左雙旋轉)。
     *
     * @param k3
     * @return 旋轉後的根節點
     */
    private AVLTreeNode<T> leftRightRotation(AVLTreeNode<T> k3) {
        k3.left = rightRightRotation(k3.left);

        return leftLeftRotation(k3);
    }

    /**
     * RL：右左對應的情況(右雙旋轉)。
     *
     * @param k1
     * @return 旋轉後的根節點
     */
    private AVLTreeNode<T> rightLeftRotation(AVLTreeNode<T> k1) {
        k1.right = leftLeftRotation(k1.right);

        return rightRightRotation(k1);
    }


    public void insert(T key) {
        mRoot = insert(mRoot, key);
    }

    /**
     * 將結點插入到AVL樹中，並返回根節點
     *
     * @param tree AVL樹的根結點
     * @param key  插入的結點的鍵值
     * @return 根節點
     */
    private AVLTreeNode<T> insert(AVLTreeNode<T> tree, T key) {
        if (tree == null) {
            // 新建節點
            return tree = new AVLTreeNode<T>(key, null, null);

        }

        int cmp = key.compareTo(tree.element);
        if (cmp < 0) {// 將key插入到"tree的左子樹"的情況
            tree.left = insert(tree.left, key);

        } else if (cmp > 0) { // 將key插入到"tree的右子樹"的情況
            tree.right = insert(tree.right, key);
        }

        return balance(tree);
    }


    private static final int ALLOWED_IMBALANCE = 1;

    private AVLTreeNode<T> balance(AVLTreeNode<T> tree) {
        if (tree == null) {
            return tree;
        }
        // 插入節點後，若AVL樹失去平衡，則進行相應的調節。
        if (height(tree.left) - height(tree.right) > ALLOWED_IMBALANCE) {

            if (height(tree.left.left) >= height(tree.left.right)) {
                leftLeftRotation(tree);
            } else {
                leftRightRotation(tree);
            }
        } else if (height(tree.right) - height(tree.left) > ALLOWED_IMBALANCE) {
            if (height(tree.right.right) >= height(tree.right.left)) {
                rightRightRotation(tree);
            } else {
                rightLeftRotation(tree);
            }
        }
        tree.height = Math.max(height(tree.left), height(tree.right)) + 1;

        return tree;
    }

    public void remove(T key) {
        AVLTreeNode<T> z;

        if ((z = search(mRoot, key)) != null)
            mRoot = remove(mRoot, z);
    }

    /*
       * (遞歸實現)查找"AVL樹x"中鍵值為key的節點
      */
    private AVLTreeNode<T> search(AVLTreeNode<T> x, T key) {
        if (x == null)
            return x;

        int cmp = key.compareTo(x.element);
        if (cmp < 0)
            return search(x.left, key);
        else if (cmp > 0)
            return search(x.right, key);
        else
            return x;
    }

    public AVLTreeNode<T> search(T key) {
        return search(mRoot, key);
    }

    /**
     * 刪除結點(z)，返回根節點
     *
     * @param tree AVL樹的根結點
     * @param z    待刪除的結點
     * @return 根節點
     */
    private AVLTreeNode<T> remove(AVLTreeNode<T> tree, AVLTreeNode<T> z) {
        if (tree == null)
            return tree;

        int cmp = z.element.compareTo(tree.element);
        if (cmp > 0) {
            tree.right = remove(tree.right, z);
        } else if (cmp < 0) {
            tree.left = remove(tree.left, z);
        } else if (tree.left != null && tree.right != null) {
            tree.element = findMin(tree.right).element;
            tree.right = remove(tree.element, tree.right);
        } else {
            tree = (tree.left != null) ? tree.left : tree.right;
        }
        return balance(tree);
    }

    private AVLTreeNode<T> findMin(AVLTreeNode<T> node) {
        if (node != null) {
            while (node.left != null) {
                node = node.left;
            }
        }
        return node;
    }

    public AVLTreeNode<T> remove(T t, AVLTreeNode<T> node) {
        if (node == null) {
            return node;
        }
        int compareResult = t.compareTo(node.element);
        if (compareResult > 0) {
            node.right = remove(t, node.right);
        } else if (compareResult < 0) {
            node.left = remove(t, node.left);
        } else if (node.left != null && node.right != null) {
            node.element = findMin(node.right).element;
            node.right = remove(node.element, node.right);
        } else {
            node = (node.left != null) ? node.left : node.right;
        }
        return node;

    }

    /*
     * 打印"二叉查找樹"
     *
     * key        -- 節點的鍵值
     * direction  --  0，表示該節點是根節點;
     *               -1，表示該節點是它的父結點的左孩子;
     *                1，表示該節點是它的父結點的右孩子。
     */
    private void print(AVLTreeNode<T> tree, T key, int direction) {
        if(tree != null) {
            if(direction==0)    // tree是根節點
                system.out.printf("%2d is root\n", tree.element, key);
            else                // tree是分支節點
                System.out.printf("%2d is %2d's %6s child\n", tree.element, key, direction==1?"right" : "left");

            print(tree.left, tree.element, -1);
            print(tree.right,tree.element,  1);
        }
    }

    public void print() {
        if (mRoot != null)
            print(mRoot, mRoot.element, 0);
    }
}

AVL樹的測試程序

public class AVLTreeTest {
    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> tree = new AVLTree<Integer>();

        System.out.printf("== 依次添加: ");
        for (i = 0; i < arr.length; i++) {
            System.out.printf("%d ", arr[i]);
            tree.insert(arr[i]);
        }
        System.out.printf("\n== 前序遍歷: ");
        tree.preOrder();

        System.out.printf("\n== 中序遍歷: ");
        tree.inOrder();

        System.out.printf("\n== 後序遍歷: ");
        tree.postOrder();
        System.out.printf("\n");

        System.out.printf("== 高度: %d\n", tree.height());
        System.out.printf("== 樹的詳細信息: \n");
        tree.print();

        i = 6;
        System.out.printf("\n== 刪除根節點: %d", i);
        tree.remove(i);

        System.out.printf("\n== 高度: %d", tree.height());
        System.out.printf("\n== 中序遍歷: ");
        tree.inOrder();
        System.out.printf("\n== 樹的詳細信息: \n");
        tree.print();
    }
}

AVL樹測試程序流程進行分析

新建AVL樹
依次添加”3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9” 到AVL樹中。

2.01 添加3,2

添加3,2都不會破壞AVL樹的平衡性。

2.02 添加1

添加1之後，AVL樹失去平衡(LL)，此時需要對AVL樹進行旋轉(LL旋轉)。旋轉過程如下：

2.03 添加4

添加4不會破壞AVL樹的平衡性。

2.04 添加5

添加5之後，AVL樹失去平衡(RR)，此時需要對AVL樹進行旋轉(RR旋轉)。旋轉過程如下：

2.05 添加6

添加6之後，AVL樹失去平衡(RR)，此時需要對AVL樹進行旋轉(RR旋轉)。旋轉過程如下：

2.06 添加7

添加7之後，AVL樹失去平衡(RR)，此時需要對AVL樹進行旋轉(RR旋轉)。旋轉過程如下：

2.07 添加16

添加16不會破壞AVL樹的平衡性。

2.08 添加15

添加15之後，AVL樹失去平衡(RR)，此時需要對AVL樹進行旋轉(RR旋轉)。旋轉過程如下：

2.09 添加14

添加14之後，AVL樹失去平衡(RL)，此時需要對AVL樹進行旋轉(RL旋轉)。旋轉過程如下：

2.10 添加13

添加13之後，AVL樹失去平衡(RR)，此時需要對AVL樹進行旋轉(RR旋轉)。旋轉過程如下：

2.11 添加12

添加12之後，AVL樹失去平衡(LL)，此時需要對AVL樹進行旋轉(LL旋轉)。旋轉過程如下：

2.12 添加11

添加11之後，AVL樹失去平衡(LL)，此時需要對AVL樹進行旋轉(LL旋轉)。旋轉過程如下：

2.13 添加10

添加10之後，AVL樹失去平衡(LL)，此時需要對AVL樹進行旋轉(LL旋轉)。旋轉過程如下：

2.14 添加8

添加8不會破壞AVL樹的平衡性。

2.15 添加9

但是添加9之後，AVL樹失去平衡(LR)，此時需要對AVL樹進行旋轉(LR旋轉)。旋轉過程如下：