AVL 樹的插入、刪除、旋轉歸納

參考鏈接：

http://blog.csdn.net/gabriel1026/article/details/6311339

 

1126號注：先前有一個概念搞混了：

　　節點的深度 Depth 是指從根節點到當前節點的長度；

　　節點的高度 Height 是指從當前節點向下，到子孫中所有葉子節點的長度的最大值。

 

 

之前簡單了解過 AVL 樹，知道概念但一直沒動手實踐過。Now

 

 AVL 樹是二叉搜索樹的一種。二叉搜索樹的規則就是：每個節點的 left child 都比自己小，right child 都比自己大。而 AVL 的在此之上又加了一個規則：每個節點的 left 深度與 right 深度只差<=1，這樣就能充分利用 二叉樹的結構，避免出現一個分支走到黑，導致搜索效率變低。如下圖：

                                             

                                這種樹結構，搜索起來完全沒有體現出二叉搜索樹的優勢

 

所以同樣多的元素，搜索樹的深度越低，就會越快的定位到搜索點。

 

AVL 樹為了保持樹的平衡，每次插入、刪除都會檢查 每個受影響的節點，深度差是否 <  1。最難的部分就是如果樹失衡，如何調整節點。插入的處理流程大致如下：

     給定一個 value，一路比較直到插入到某個位置。然后查找哪些節點因此而失衡，針對第一個失衡的節點進行旋轉。

 

下面是我從另一個博客上找來的圖（ http://blog.csdn.net/gabriel1026/article/details/6311339），介紹了四種失衡的情況，以及調整方式：

注：圖中紅色的小塊 表示新插入的元素，A 點表示從插入點向上，發現的第一個失衡的點。

 

      AVL樹的旋轉一共有四種情形，注意所有旋轉情況都是圍繞着使得二叉樹不平衡的第一個節點展開的。

1： 

     

     圖中在 Bl 下新插入一個子節點，導致 A 左側深度為 3，右側為 1，失衡。右旋。

2：

     

3：

     

 

4：

 

不知道大家看明白了調整的規則嗎？

如果您看明白了，你真是大牛！！！

沒看圖之前我大致明白了四種調整規則，看了后兩幅圖片之后，徹底迷糊了。完全不知道如何用程序來表示四種規則，也不知道怎么從一棵樹中提取到這四個特征。。。后兩張圖折磨了我一天多，才發現：后兩張圖應該是存在邏輯錯誤的。。。

     AVL 樹每次插入之前，以及插入之后，都應該是平衡的。而 圖3 和圖4，插入之前就不平衡：拿圖三來說：插入之前，A 的 left 深度為3，right 深度為 1，本身就有問題

 

 

雖然上面的圖有問題，但是介紹的思路是非常正確的，只是檢查到底符合 LL、RR、LR、RL 中哪個特征時，被帶跑偏了。

所以明白了這四種調整方式后，下一步就是用程序的思維，檢查何時用哪種規則了。這一點我認為網上的博客介紹的也不太詳細，我這理解力一般的人，看過教程后，實現起來依舊是一團麻。下面是我用到的插入流程：

     1：拿到新節點 newNode，根據左小右大的二叉搜索樹規則，一路定位到一個具體的節點 currNode，把 newNode 當成 currNode 的 child 插入到樹中。（不用記錄 newNode 是 currNode 的 left 還是 right ）

     2：檢查 currNode 是否失衡，如果沒有失衡，就檢查 currNode 的 parent，不失衡就在檢查 parent 的 parent….. 這樣直到拿到一個失衡節點（如果直到根節點依舊平衡，那當前樹就不用做任何調整），把失衡點當成 currNode

     3：關鍵點的平衡來了：

          如果 Depth(currNode.left) - Depth(currNode.right) = 2：說明左側深度大於右側深度，可能是 LL、LR 中的一種：此時檢查 newNode 和 currNode、 currNode.left 的大小關系

               1）如果 newNode 比 currNode 小，並且 newNode 比 currNode.left 小，此時符合 LL：對 currNode 右旋；

               2）如果 newNode 比 currNode 小，但是 newNode 比 currNode.left 大，此時符合 LR：先對 currNode.left 左旋，然后對 currNode 右旋；

          如果 Depth(currNode.right) - Depth(currNode.left) = 2：說明右側深度大於左側深度，可能是 RR、RL 中的一種：此時檢查 newNode 和 currNode、 currNode.right 的大小關系：

               1）如果 newNode 比 currNode 大，並且 newNode 比 currNode.right 大，符合 RR，對 currNode 左旋；

               2）如果 newNode 比 currNode 大，並且 newNode 比 currNode.right 小，符合 RL：先對 currNode.right 右旋，然后對 currNode 左旋；

插入、調整結束。

 

中間有幾個容易混的地方。這樣敘述起來，用程序實現就很方便了。剩下的就是 左旋、右旋的函數實現，這兩個函數需要特別小心，每個節點的 parent、left、right 都要很小心的處理。基本上包含四個函數：

     insert 負責執行 1

     balance 負責執行 2、3、4

     leftRotate、rightRotate 函數用來實現旋轉。

代碼我在最后統一貼出來。

 

 

 

插入搞定了，還有刪除操作：刪除的流程如下：

     1：拿到要刪除的數字 value，從根節點開始比對，知道找到一個要刪除的節點：currNode （沒找到正好不用刪了 →_→）

     2：從左子樹中找到一個最大值（左子樹中的值都比 currNode 小）：targetNode（如果左子樹為空，那就直接把 right 節點上位；如果 right 也是空的，那就直接刪掉 currNode 就好了）

     3：把 targetNode 放到 currNode 的位置上：因為每個 節點都有 parent、left、right 三個關聯點，要仔細處理（錯誤了好幾次才正確→_→）

     4：和 插入類似，從 targetNode 開始一路向上，找到第一個失衡點。此時只有 LL 和 RR 兩種失衡情況，判斷起來相對容易些

 

 

AVL 樹最基本的插入和刪除就是這樣了。插入刪除過程中，具體為什么旋轉、為什么使用這種規則，是否覆蓋到了所有的特例等問題，都是有規律可以歸納的。對這些規律我還比較模糊，知其然不知其所以然。。。樹是一個很神奇的數據結構，諸多奇思妙想都能用樹結構來實現，還要多想想樹的規律。

 

JS 代碼如下：

 

 

/**
 * Created by CG on 16/11/20.
 */



var TreeNode = function(){
    this.parent = null;
    this.left = null;
    this.right = null;

    this.value = null;
};


var AVLTree = {

    insert : function (value) {
        this.log("新加節點:new add: " + value);
        if(this._tree == null){
            var node = new TreeNode();
            node.value = value;
            this._tree = node;
            return;
        }

        var newNode = new TreeNode();
        newNode.value = value;

        var currNode = this._tree;
        while(true){
            if(currNode == null){
                this.log(" ======== currNode: null");
                return;
            }

            //走向左子樹
            if(value <= currNode.value){
                this.log(" to left:   value: " + value + " currValue: " + currNode.value);
                if(currNode.left){
                    currNode = currNode.left;
                    continue;
                }
                else {
                    newNode.parent = currNode;
                    currNode.left = newNode;
                    this.balanceTree(currNode, newNode);
                    break;
                }
            }
            //走向右子樹
            else {
                this.log(" to right:   value: " + value + " currValue: " + currNode.value);
                if(currNode.right){
                    currNode = currNode.right;
                    continue;
                }
                else {
                    newNode.parent = currNode;
                    currNode.right = newNode;
                    this.balanceTree(currNode, newNode);
                    break;
                }
            }
        }
    },
    balanceTree : function (currNode, newNode) {
        if(!currNode){
            return;
        }

        this.printTreeByLevel();
        while(currNode){
            this.log("---------===========--- check if adjust: " + currNode.value);
            if(currNode.parent){
                this.log(" parent: " + currNode.parent.value);
            }
            var leftDepth   = this.calcuDepth(currNode.left);
            var rightDepth  = this.calcuDepth(currNode.right);
            this.log("leftDepth: " + leftDepth + "  rightDepth: " + rightDepth);
            if(leftDepth - rightDepth == 2){
                if(newNode == null){
                    this.rightRotate(currNode);
                }
                else if(newNode.value < currNode.value && newNode.value < currNode.left.value){
                    this.log("LL");
                    this.rightRotate(currNode);
                }
                else if(newNode.value < currNode.value && newNode.value > currNode.left.value){
                    this.log("LR");
                    this.leftRotate(currNode.left);
                    this.rightRotate(currNode);
                }
            }
            else if(rightDepth - leftDepth == 2){
                if(newNode == null){
                    this.leftRotate(currNode);
                }
                else if(newNode.value > currNode.value && newNode.value > currNode.right.value){
                    this.log("RR");
                    this.leftRotate(currNode);
                }
                else if(newNode.value > currNode.value && newNode.value < currNode.right.value){
                    this.log("RL");
                    this.rightRotate(currNode.right);
                    this.leftRotate(currNode);
                }
            }

            currNode = currNode.parent;
            this.printTreeByLevel();
        }
    },
    leftRotate : function (currNode) {
        this.log("leftRotate: " + currNode.value);
        var oldRight = currNode.right;

        //如果當前節點就是根節點，更新外界引用的根節點
        if(currNode == this._tree){
            this._tree = oldRight;
        }
        else {
            //更新變動前的 currNode 的 parent 的指向
            if(currNode.parent.left == currNode){
                currNode.parent.left = oldRight;
            }
            else if(currNode.parent.right == currNode){
                currNode.parent.right = oldRight;
            }
        }

        //更新 curr 和 oldRight 的 parent
        oldRight.parent = currNode.parent;

        //更新 curr 和 oldRight 的 child
        currNode.right = oldRight.left;
        if(oldRight.left){
            oldRight.left.parent = currNode;
        }

        oldRight.left = currNode;
        currNode.parent = oldRight;

        this._tree.parent = null;
        return oldRight;
    },
    rightRotate : function (currNode) {
        this.log("rightRotate: " + currNode.value);
        var oldLeft = currNode.left;

        //如果當前節點就是根節點，更新外界引用的根節點
        if(currNode == this._tree){
            this._tree = oldLeft;
        }
        else {
            //更新變動前的 currNode 的 parent 的指向
            if(currNode.parent.left == currNode){
                currNode.parent.left = oldLeft;
            }
            else if(currNode.parent.right == currNode){
                currNode.parent.right = oldLeft;
            }
        }

        //更新 curr 和 oldLeft 的 parent
        oldLeft.parent = currNode.parent;

        //更新 curr 和 oldLeft 的 child
        currNode.left = oldLeft.right;
        if(oldLeft.right){
            oldLeft.right.parent = currNode;
        }

        oldLeft.right = currNode;
        currNode.parent = oldLeft;

        this._tree.parent = null;
        return oldLeft;
    },

    /**
     * 計算左右節點的深度。葉子節點的深度都是 1，依次向上加 1
     * @param treeNode
     * @returns {number}
     */
    calcuDepth : function (treeNode) {
        if(!treeNode){
            return 0;
        }
        if(treeNode.left == null && treeNode.right == null){
            return 1;
        }
        return 1 + Math.max(this.calcuDepth(treeNode.left), this.calcuDepth(treeNode.right));
    },

    /**
     * 從樹中刪除一個節點
     * @param value
     */
    remove : function (value) {
        this.log(" ===== 將要刪除元素：" + value);
        if(!value){
            return;
        }

        //定位到節點
        var currNode = this._tree;
        while(currNode){
            if(currNode.value == value){
                break;
            }
            currNode = value > currNode.value ? currNode.right : currNode.left;
        }
        if(currNode.value != value){
            this.log("沒找到啊");
            return;
        }

        var targetNode = null;
        //刪除該節點
        if(currNode.left){
            //有左子樹，找到其中最大值來替代空位
            targetNode = this.findMaxNode(currNode.left);
            this.log(" == currNode.left: " + targetNode.value);

            //更新 target 父節點的 child 指向
            if(targetNode.parent != currNode){
                var newChild = targetNode.left ? targetNode.left : targetNode.right;
                if(targetNode.parent.left == targetNode){
                    targetNode.parent.left = newChild;
                }
                else {
                    targetNode.parent.right = newChild;
                }
            }
            //更新 target 的 parent 指向
            targetNode.parent = currNode.parent;

            // 更新 target 的 right 指向
            targetNode.right = currNode.right;
            if(currNode.right){
                currNode.right.parent = targetNode;
            }
            // 更新 target 的 left 指向 、、一定要注意避免自身死循環
            if(currNode.left != targetNode){
                targetNode.left = currNode.left;
                currNode.left.parent = targetNode;
            }
        }
        //沒有左子樹，但是有右子樹，直接把右子樹提上去就好了
        else if(currNode.right){
            targetNode = currNode.right;
            targetNode.parent = currNode.parent;
            this.log(" == currNode.right: " + targetNode.value);
        }
        //如果 curr 是葉子節點，只要更新 curr 的 parent 就可以了，沒有額外處理

        //更新 curr 父節點的 child 指向
        if(currNode.parent && currNode.parent.left == currNode){
            currNode.parent.left = targetNode;
        }
        else if(currNode.parent && currNode.parent.right == currNode){
            currNode.parent.right = targetNode;
        }
        else {
            this._tree = targetNode; //說明是 根節點
        }

        this.log(" +++++++++++++ ");
        this.printTreeByLevel();
        this.balanceTree(targetNode == null ? currNode.parent : targetNode);
        this.log(" +++++++++++++ ");
    },


    findMaxNode : function(treeNode){
        while(treeNode){
            if(treeNode.right){
                treeNode = treeNode.right;
            }
            else {
                return treeNode;
            }
        }
        return treeNode;
    },



    log : function (str) {
        console.log(str);
    },
    /**
    * 按照層級打印一棵樹的各層節點名字
    **/
    printTreeByLevel : function () {
        this.log("-----------------------");
        if(!this._tree){
            this.log(" === empty ===");
            return;
        }
        var nodeList = [];
        nodeList.push(this._tree);
        while(nodeList.length > 0){
            var len = nodeList.length;
            var value = "";
            for(var i=0; i<len; ++i){
                var currNode = nodeList[i];
                value += currNode.value + " ";
                if(currNode.left){
                    nodeList.push(currNode.left);
                }
                if(currNode.right){
                    nodeList.push(currNode.right);
                }
            }
            this.log(value);

            nodeList = nodeList.slice(len);
        }
    },
};


AVLTree.printTreeByLevel();
AVLTree.log("====================================================================================================");
var list = [3,7,9,23,45, 1,5,14,25,24, 13,11, 26];
for(var index in list){
    AVLTree.insert(list[index]);
}
AVLTree.log("====================================================================================================");
AVLTree.printTreeByLevel();
// AVLTree.remove(1);
// AVLTree.remove(25);
// AVLTree.printTreeByLevel();