AVL樹的JAVA實現及AVL樹的旋轉算法

1，AVL樹又稱平衡二叉樹，它首先是一顆二叉查找樹，但在二叉查找樹中，某個結點的左右子樹高度之差的絕對值可能會超過1，稱之為不平衡。而在平衡二叉樹中，任何結點的左右子樹高度之差的絕對值會小於等於 1。

2，為什么需要AVL樹呢？在二叉查找樹中最壞情況下查找某個元素的時間復雜度為O(n)，而AVL樹能保證查找操作的時間復雜度總為O(logn)。

     對於一棵BST樹而言，不僅有查找操作，也有插入、刪除等改變樹的形態的操作。隨着不斷地插入、刪除，BST樹有可能會退化成鏈表的形式，使得查找的時間復雜度變成O(N)，這種情形下，BST樹的結構非常不平衡了。為了保持樹的平衡，需要對樹的形態做一些限制，因此，引入了AVL樹，以保證樹的左右子樹高度之差的絕對值小於等於1。

3，AVL樹的JAVA代碼實現：

 AVLTree  繼承 BinarySearchTree 並改寫 添加節點的add方法，在add方法中判斷插入元素后是否導致樹不平衡，當不平衡時需要通過旋轉進行調整。何時進行旋轉調整是通過左右子樹的高度之差進行判斷的。這里通過rebalance方法使得某結點保持平衡：整個程序的完成代碼參考最后。

private BinaryNodeInterface<T> rebalance(BinaryNodeInterface<T> nodeN){
        int heightDifference = getHeightDifference(nodeN);
        if(heightDifference > 1){//左子樹比右子樹高
            if(getHeightDifference(nodeN.getLeftChild()) > 0)
                nodeN = rotateRight(nodeN);//插入在左子樹的左孩子中
            else
                nodeN = rotateLeftRight(nodeN);
        }
        else if(heightDifference < -1){//右子樹比左子樹高
            if(getHeightDifference(nodeN.getRightChild()) < 0)
                nodeN = rotateLeft(nodeN);//插入在右子樹的右孩子中
            else
                nodeN = rotateRightLeft(nodeN);
        }
        return nodeN;
    }

 

4，AVL樹的平衡保證算法

當向AVL樹中插入或者刪除元素時，可能打破樹的平衡。這時，需要通過旋轉來調整使之重新變成一顆AVL樹。（這里討論插入元素時的調整）

設 N 表示最接近新葉子的不平衡結點，由於插入元素之前樹是平衡的，則插入之后不會有比 N 更高的不平衡結點。（樹根的高度為 1 ）

一共有 4 種原因導致結點 N 不平衡：

①在 結點 N 的左孩子的左子樹中發生了插入操作

進行右旋轉調整：即對結點 N 進行右旋轉，算法如下：

算法 rotateRight(nodeN)
nodeL = nodeN 的左孩子
將nodeN 的左孩子置為 nodeL 的右孩子
將 nodeL 的右孩子置為 nodeN
return nodeL

 

②在 結點N 的右孩子的右子樹中發生了插入操作

進行左旋轉調整：即對結點N進行左旋轉，算法如下：

算法 rotateLeft(nodeN)
nodeR = nodeN 的右孩子
將 nodeN 的右孩子置為 nodeR 的左孩子
將 nodeR 的左孩子置為 nodeN
return nodeR

 

③在 結點N 的右孩子的左子樹中發生了插入操作

進行右-左旋轉，即先對結點N 的孫子(孩子的孩子，"位於新插入元素的那個方向")進行右旋轉；再對結點N 的新孩子進行左旋轉，算法如下：

算法 rotateRightLeft(nodeN)
nodeR = nodeN 的右孩子
將 nodeN 的右孩子置為由 rotateRight(nodeN 的孩子的孩子)返回的結點
return rotateLeft(nodeN 的新的右孩子)

 

④在 結點N 的左孩子的右子樹中發生了插入操作

進行左-右旋轉，即先對結點N的孫子進行左旋轉，再對結點N的新孩子進行右旋轉，算法如下：

算法 rotateLeftRight(nodeN)
nodeL = nodeN 的左孩子
將 nodeN 的左孩子置為由 rotateLeft(nodeN 孩子的孩子）返回的結點
return rotateLeft(nodeN 新的左孩子)

 

5，關於樹的平衡性的進一步討論

除了AVL樹之外，還有2-3樹、2-4樹、紅黑樹等一系列帶有平衡性質的樹。其中2-3樹和2-4樹是完全平衡的，即所有的葉子位於同一層。2-3樹的結點至多有兩個數據元素，2-4樹的結點至多有三個數據元素，這樣使得在相同的結點數目下，一般，AVL樹比2-3樹要高，2-3樹比2-4樹要高，但是在查找過程中內部結點的比較次數2-4樹比2-3要多，2-3樹比AVL樹要多。因此，總體上看，AVL樹、2-3樹、2-4樹、紅黑樹的查找都是O(logn)操作。維護平衡性由難到易的排列： AVL樹 > 2-3樹 > 2-4樹 ·= 紅黑樹。其次，隨着對於結點含有3個以上的數據元素的查找樹的性能反而會降低，因此這也是為什么沒有2-5樹……的原因。。。

 

2018.12更新

6， 紅黑樹與AVL樹的對比

不管是紅黑樹還是AVL樹，不僅要有效地支持查找，還需要有效地支持插入和刪除，插入和刪除操作會改變樹的形態，如果不做一定的調整，樹的結構就會變得不平衡，因此不管是AVL樹還是紅黑樹都有“旋轉”操作。
但是，二者的“旋轉”操作的代價是不一樣的。在最壞的情況下，AVL樹的旋轉操作代價能達到O(logN)，而紅黑樹的旋轉操作代價為O(1)。
由於插入、刪除操作會引發樹的旋轉，因此：紅黑樹比AVL樹更適合於插入、刪除元素更頻繁的情形，而AVL樹更適合於查詢非常多，插入、刪除很少的場景。
另外，紅黑樹在JDK集合框架中應用廣泛，比如HashMap就引入了紅黑樹，可以讓HashMap在存在大量的鍵沖突的情況下，仍然能夠保證快速地查詢。
在正常情況下，HashMap的get操作時間復雜度為O(1)，在存在大量沖突時，get操作時間復雜度退化為O(logN)

 

AVL樹的完整JAVA代碼實現：

package searchtree;

import tree.BinaryNode;
import tree.BinaryNodeInterface;

public class AVLTree<T extends Comparable<? super T>> extends BinarySearchTree<T> implements SearchTreeInterface<T>,java.io.Serializable {
    public AVLTree(){
        super();
    }
    
    public AVLTree(T rootEntry){
        super(rootEntry);
    }

    /*
     *@Task : 在AVL樹中添加元素
     */
    public T add(T newEntry){
        T result = null;
        if(isEmpty())
            setRootNode(new BinaryNode<T>(newEntry));
        else
        {
            BinaryNodeInterface<T> rootNode = getRootNode();
            result = addEntry(rootNode, newEntry);
            setRootNode(rebalance(rootNode));
        }
        return result;
    }
    
    private T addEntry(BinaryNodeInterface<T> rootNode, T newEntry){
        assert rootNode != null;
        T result = null;
        int comparison = newEntry.compareTo(rootNode.getData());//待添加元素與樹中已有元素比較以確定添加的位置
        if(comparison == 0){//待添加元素已存在於樹中
            result = rootNode.getData();
            rootNode.setData(newEntry);//將新元素替換舊元素
        }
        else if(comparison < 0){//添加到左子樹中
            if(rootNode.hasLeftChild()){//繼承遞歸比較
                BinaryNodeInterface<T> leftChild = rootNode.getLeftChild();
                result = addEntry(leftChild, newEntry);
                rootNode.setLeftChild(rebalance(leftChild));
            }
            else
                rootNode.setLeftChild(new BinaryNode<T>(newEntry));
        }
        else//添加到右子樹中
        {
            assert comparison > 0;
            if(rootNode.hasRightChild()){
                BinaryNodeInterface<T> rightChild = rootNode.getRightChild();
                result = addEntry(rightChild, newEntry);
                rootNode.setRightChild(rebalance(rightChild));
            }
            else
                rootNode.setRightChild(new BinaryNode<T>(newEntry));
        }
        return result;
    }
    
    public T remove(T newEntry){
        return null;//暫未實現刪除操作
    }
    
    /*
     * @Task: 在 nodeN 結點上進行右旋操作
     */
    private BinaryNodeInterface<T> rotateRight(BinaryNodeInterface<T> nodeN){
        BinaryNodeInterface<T> nodeL = nodeN.getLeftChild();
        nodeN.setLeftChild(nodeL.getRightChild());
        nodeL.setRightChild(nodeN);
        return nodeL;
    }
    
    private BinaryNodeInterface<T> rotateLeft(BinaryNodeInterface<T> nodeN){
        BinaryNodeInterface<T> nodeR = nodeN.getRightChild();
        nodeN.setRightChild(nodeR.getLeftChild());
        nodeR.setLeftChild(nodeN);
        return nodeR;
    }
    
    private BinaryNodeInterface<T> rotateRightLeft(BinaryNodeInterface<T> nodeN){
        BinaryNodeInterface<T> nodeR = nodeN.getRightChild();
        nodeN.setRightChild(rotateRight(nodeR));
        return rotateLeft(nodeN);
    }
    
    private BinaryNodeInterface<T> rotateLeftRight(BinaryNodeInterface<T> nodeN){
        BinaryNodeInterface<T> nodeL = nodeN.getLeftChild();
        nodeN.setLeftChild(rotateLeft(nodeL));
        return rotateRight(nodeN);
    }
    
    private BinaryNodeInterface<T> rebalance(BinaryNodeInterface<T> nodeN){
        int heightDifference = getHeightDifference(nodeN);
        if(heightDifference > 1){//左子樹比右子樹高
            if(getHeightDifference(nodeN.getLeftChild()) > 0)
                nodeN = rotateRight(nodeN);//插入在左子樹的左孩子中
            else
                nodeN = rotateLeftRight(nodeN);
        }
        else if(heightDifference < -1){//右子樹比左子樹高
            if(getHeightDifference(nodeN.getRightChild()) < 0)
                nodeN = rotateLeft(nodeN);//插入在右子樹的右孩子中
            else
                nodeN = rotateRightLeft(nodeN);
        }
        return nodeN;
    }
    
    //獲得結點nodeN的左右子樹的高度之差
    private int getHeightDifference(BinaryNodeInterface<T> nodeN){
        int leftHeight = 0;
        int rightHeight = 0;
        if(nodeN.getLeftChild() != null){
            leftHeight = nodeN.getLeftChild().getHeight();
        }
        if(nodeN.getRightChild() != null){
            rightHeight = nodeN.getRightChild().getHeight();
        }
        return leftHeight - rightHeight;
    }
}

 

整個實現的依賴代碼參考：https://github.com/hapjin/data-structures-and-abstraction-with-java 中的tree、searchtree、list 目錄下代碼。