一步一步寫平衡二叉樹（AVL樹）

 一步一步寫平衡二叉樹（AVL樹）

作者：C小加 更新時間：2012-8-20

　　平衡二叉樹（Balanced Binary Tree）是二叉查找樹的一個進化體，也是第一個引入平衡概念的二叉樹。1962年，G.M. Adelson-Velsky 和 E.M. Landis發明了這棵樹，所以它又叫AVL樹。平衡二叉樹要求對於每一個節點來說，它的左右子樹的高度之差不能超過1，如果插入或者刪除一個節點使得高度之差大於1，就要進行節點之間的旋轉，將二叉樹重新維持在一個平衡狀態。這個方案很好的解決了二叉查找樹退化成鏈表的問題，把插入，查找，刪除的時間複雜度最好情況和最壞情況都維持在O(logN)。但是頻繁旋轉會使插入和刪除犧牲掉O(logN)左右的時間，不過相對二叉查找樹來說，時間上穩定了很多。

　　平衡二叉樹實現的大部分過程和二叉查找樹是一樣的（學平衡二叉樹之前一定要會二叉查找樹），區別就在於插入和刪除之後要寫一個旋轉算法去維持平衡，維持平衡需要藉助一個節點高度的屬性。我參考了機械工業出版社的《數據結構與算法分析-C語言描述》寫了一個C++版的代碼。這本書的AVLTree講的很好，不過沒有很完整的去描述。我會一步一步的講解如何寫平衡二叉樹，重點是平衡二叉樹的核心部分，也就是旋轉算法。

第一步：節點信息

　　相對於二叉查找樹的節點來說，我們需要用一個屬性二叉樹的高度，目的是維護插入和刪除過程中的旋轉算法。

代碼如下：

//AVL樹節點信息
template<class T>
class TreeNode
{
    public:
        TreeNode():lson(NULL),rson(NULL),freq(1),hgt(0){}
        T data;//值
        int hgt;//以此節點爲根的樹的高度
        unsigned int freq;//頻率
        TreeNode* lson;//指向左兒子的地址
        TreeNode* rson;//指向右兒子的地址
};

第二步：平衡二叉樹類的聲明

　　聲明中的旋轉函數將在後邊的步驟中詳解。

代碼如下：

//AVL樹類的屬性和方法聲明
template<class T>
class AVLTree
{
    private:
        TreeNode<T>* root;//根節點
        void insertpri(TreeNode<T>* &node,T x);//插入
        TreeNode<T>* findpri(TreeNode<T>* node,T x);//查找
        void insubtree(TreeNode<T>* node);//中序遍歷
        void Deletepri(TreeNode<T>* &node,T x);//刪除
        int height(TreeNode<T>* node);//求樹的高度
        void SingRotateLeft(TreeNode<T>* &k2);//左左情況下的旋轉
        void SingRotateRight(TreeNode<T>* &k2);//右右情況下的旋轉
        void DoubleRotateLR(TreeNode<T>* &k3);//左右情況下的旋轉
        void DoubleRotateRL(TreeNode<T>* &k3);//右左情況下的旋轉
        int Max(int cmpa,int cmpb);//求最大值

    public:
        AVLTree():root(NULL){}
        void insert(T x);//插入接口
        TreeNode<T>* find(T x);//查找接口
        void Delete(T x);//刪除接口
        void traversal();//遍歷接口

};

第三步：兩個輔助方法

　　旋轉算法需要藉助於兩個功能的輔助，一個是求樹的高度，一個是求兩個高度的最大值。這裏規定，一棵空樹的高度爲-1，只有一個根節點的樹的高度爲0，以後每多一層高度加1。爲了解決指針NULL這種情況，寫了一個求高度的函數，這個函數還是很有必要的。

代碼如下：

//計算以節點爲根的樹的高度
template<class T>
int AVLTree<T>::height(TreeNode<T>* node)
{
    if(node!=NULL)
        return node->hgt;
    return -1;
}
//求最大值
template<class T>
int AVLTree<T>::Max(int cmpa,int cmpb)
{
    return cmpa>cmpb?cmpa:cmpb;
}

第四步：旋轉

　　對於一個平衡的節點，由於任意節點最多有兩個兒子，因此高度不平衡時，此節點的兩顆子樹的高度差2.容易看出，這種不平衡出現在下面四種情況：

　　1、6節點的左子樹3節點高度比右子樹7節點大2，左子樹3節點的左子樹1節點高度大於右子樹4節點，這種情況成爲左左。

　　2、6節點的左子樹2節點高度比右子樹7節點大2，左子樹2節點的左子樹1節點高度小於右子樹4節點，這種情況成爲左右。

　　3、2節點的左子樹1節點高度比右子樹5節點小2，右子樹5節點的左子樹3節點高度大於右子樹6節點，這種情況成爲右左。

　　4、2節點的左子樹1節點高度比右子樹4節點小2，右子樹4節點的左子樹3節點高度小於右子樹6節點，這種情況成爲右右。

　　從圖2中可以可以看出，1和4兩種情況是對稱的，這兩種情況的旋轉算法是一致的，只需要經過一次旋轉就可以達到目標，我們稱之爲單旋轉。2和3兩種情況也是對稱的，這兩種情況的旋轉算法也是一致的，需要進行兩次旋轉，我們稱之爲雙旋轉。

第五步：單旋轉

　　單旋轉是針對於左左和右右這兩種情況的解決方案，這兩種情況是對稱的，只要解決了左左這種情況，右右就很好辦了。圖3是左左情況的解決方案，節點k2不滿足平衡特性，因爲它的左子樹k1比右子樹Z深2層，而且k1子樹中，更深的一層的是k1的左子樹X子樹，所以屬於左左情況。

　　爲使樹恢復平衡，我們把k2變成這棵樹的根節點，因爲k2大於k1，把k2置於k1的右子樹上，而原本在k1右子樹的Y大於k1，小於k2，就把Y置於k2的左子樹上，這樣既滿足了二叉查找樹的性質，又滿足了平衡二叉樹的性質。

　　這樣的操作只需要一部分指針改變，結果我們得到另外一顆二叉查找樹，它是一棵AVL樹，因爲X向上一移動了一層，Y還停留在原來的層面上，Z向下移動了一層。整棵樹的新高度和之前沒有在左子樹上插入的高度相同，插入操作使得X高度長高了。因此，由於這顆子樹高度沒有變化，所以通往根節點的路徑就不需要繼續旋轉了。

代碼如下：

//左左情況下的旋轉
template<class T>
void AVLTree<T>::SingRotateLeft(TreeNode<T>* &k2)
{
    TreeNode<T>* k1;
    k1=k2->lson;
    k2->lson=k1->rson;
    k1->rson=k2;

    k2->hgt=Max(height(k2->lson),height(k2->rson))+1;
    k1->hgt=Max(height(k1->lson),k2->hgt)+1;
}
//右右情況下的旋轉
template<class T>
void AVLTree<T>::SingRotateRight(TreeNode<T>* &k2)
{
    TreeNode<T>* k1;
    k1=k2->rson;
    k2->rson=k1->lson;
    k1->lson=k2;

    k2->hgt=Max(height(k2->lson),height(k2->rson))+1;
    k1->hgt=Max(height(k1->rson),k2->hgt)+1;
}

第六步：雙旋轉

　　對於左右和右左這兩種情況，單旋轉不能使它達到一個平衡狀態，要經過兩次旋轉。雙旋轉是針對於這兩種情況的解決方案，同樣的，這樣兩種情況也是對稱的，只要解決了左右這種情況，右左就很好辦了。圖4是左右情況的解決方案，節點k3不滿足平衡特性，因爲它的左子樹k1比右子樹Z深2層，而且k1子樹中，更深的一層的是k1的右子樹k2子樹，所以屬於左右情況。

 　　爲使樹恢復平衡，我們需要進行兩步，第一步，把k1作爲根，進行一次右右旋轉，旋轉之後就變成了左左情況，所以第二步再進行一次左左旋轉，最後得到了一棵以k2爲根的平衡二叉樹樹。

代碼如下：

//左右情況的旋轉
template<class T>
void AVLTree<T>::DoubleRotateLR(TreeNode<T>* &k3)
{
    SingRotateRight(k3->lson);
    SingRotateLeft(k3);
}
//右左情況的旋轉
template<class T>
void AVLTree<T>::DoubleRotateRL(TreeNode<T>* &k3)
{
    SingRotateLeft(k3->rson);
    SingRotateRight(k3);
}

 

 第七步：插入

　　插入的方法和二叉查找樹基本一樣，區別是，插入完成後需要從插入的節點開始維護一個到根節點的路徑，每經過一個節點都要維持樹的平衡。維持樹的平衡要根據高度差的特點選擇不同的旋轉算法。

代碼如下：

//插入
template<class T>
void AVLTree<T>::insertpri(TreeNode<T>* &node,T x)
{
    if(node==NULL)//如果節點爲空,就在此節點處加入x信息
    {
        node=new TreeNode<T>();
        node->data=x;
        return;
    }
    if(node->data>x)//如果x小於節點的值,就繼續在節點的左子樹中插入x
    {
        insertpri(node->lson,x);
        if(2==height(node->lson)-height(node->rson))
            if(x<node->lson->data)
                SingRotateLeft(node);
            else
                DoubleRotateLR(node);
    }
    else if(node->data<x)//如果x大於節點的值,就繼續在節點的右子樹中插入x
    {
        insertpri(node->rson,x);
        if(2==height(node->rson)-height(node->lson))//如果高度之差爲2的話就失去了平衡,需要旋轉
            if(x>node->rson->data)
                SingRotateRight(node);
            else
                DoubleRotateRL(node);
    }
    else ++(node->freq);//如果相等,就把頻率加1
    node->hgt=Max(height(node->lson),height(node->rson));
}
//插入接口
template<class T>
void AVLTree<T>::insert(T x)
{
    insertpri(root,x);
}

 

第八步：查找

和二叉查找樹相比，查找方法沒有變法，不過根據存儲的特性，AVL樹能維持在一個O(logN)的穩定的時間，而二叉查找樹則相當不穩定。

代碼如下：

//查找
template<class T>
TreeNode<T>* AVLTree<T>::findpri(TreeNode<T>* node,T x)
{
    if(node==NULL)//如果節點爲空說明沒找到,返回NULL
    {
        return NULL;
    }
    if(node->data>x)//如果x小於節點的值,就繼續在節點的左子樹中查找x
    {
        return findpri(node->lson,x);
    }
    else if(node->data<x)//如果x大於節點的值,就繼續在節點的左子樹中查找x
    {
        return findpri(node->rson,x);
    }
    else return node;//如果相等,就找到了此節點
}
//查找接口
template<class T>
TreeNode<T>* AVLTree<T>::find(T x)
{
    return findpri(root,x);
}

 

第九步：刪除

　　刪除的方法也和二叉查找樹的一致，區別是，刪除完成後，需要從刪除節點的父親開始向上維護樹的平衡一直到根節點。

代碼如下：

//刪除
template<class T>
void AVLTree<T>::Deletepri(TreeNode<T>* &node,T x)
{
    if(node==NULL) return ;//沒有找到值是x的節點
    if(x < node->data)
    {
         Deletepri(node->lson,x);//如果x小於節點的值,就繼續在節點的左子樹中刪除x
         if(2==height(node->rson)-height(node->lson))
            if(node->rson->lson!=NULL&&(height(node->rson->lson)>height(node->rson->rson)) )
                DoubleRotateRL(node);
            else
                SingRotateRight(node);
    }

    else if(x > node->data)
    {
         Deletepri(node->rson,x);//如果x大於節點的值,就繼續在節點的右子樹中刪除x
         if(2==height(node->lson)-height(node->rson))
            if(node->lson->rson!=NULL&& (height(node->lson->rson)>height(node->lson->lson) ))
                DoubleRotateLR(node);
            else
                SingRotateLeft(node);
    }

    else//如果相等,此節點就是要刪除的節點
    {
        if(node->lson&&node->rson)//此節點有兩個兒子
        {
            TreeNode<T>* temp=node->rson;//temp指向節點的右兒子
            while(temp->lson!=NULL) temp=temp->lson;//找到右子樹中值最小的節點
            //把右子樹中最小節點的值賦值給本節點
            node->data=temp->data;
            node->freq=temp->freq;
            Deletepri(node->rson,temp->data);//刪除右子樹中最小值的節點
            if(2==height(node->lson)-height(node->rson))
            {
                if(node->lson->rson!=NULL&& (height(node->lson->rson)>height(node->lson->lson) ))
                    DoubleRotateLR(node);
                else
                    SingRotateLeft(node);
            }
        }
        else//此節點有1個或0個兒子
        {
            TreeNode<T>* temp=node;
            if(node->lson==NULL)//有右兒子或者沒有兒子
            node=node->rson;
            else if(node->rson==NULL)//有左兒子
            node=node->lson;
            delete(temp);
            temp=NULL;
        }
    }
    if(node==NULL) return;
    node->hgt=Max(height(node->lson),height(node->rson))+1;
    return;
}
//刪除接口
template<class T>
void AVLTree<T>::Delete(T x)
{
    Deletepri(root,x);
}

 

第十步：中序遍歷

代碼如下：

//中序遍歷函數
template<class T>
void AVLTree<T>::insubtree(TreeNode<T>* node)
{
    if(node==NULL) return;
    insubtree(node->lson);//先遍歷左子樹
    cout<<node->data<<" ";//輸出根節點
    insubtree(node->rson);//再遍歷右子樹
}
//中序遍歷接口
template<class T>
void AVLTree<T>::traversal()
{
    insubtree(root);
}

 

第十一步：關於效率

　　此數據結構插入、查找和刪除的時間複雜度均爲O(logN)，但是插入和刪除需要額外的旋轉算法需要的時間，有時旋轉過多也會影響效率。

　　關於遞歸和非遞歸。我用的是遞歸的方法進行插入，查找和刪除，而非遞歸的方法一般來說要比遞歸的方法快很多，但是我感覺非遞歸的方法寫出來會比較困難，所以我還是選擇了遞歸的方法。

　　還有一種效率的問題是關於高度信息的存儲，由於我們需要的僅僅是高度的差，不需要知道這棵樹的高度，所以只需要使用兩個二進制位就可以表示這個差。這樣可以避免平衡因子的重複計算，可以稍微的加快一些速度，不過代碼也喪失了相對簡明性和清晰度。如果採用遞歸寫法的話，這種微加速就更顯得微乎其微了。

 

　　如果有哪些不對的或者不清晰的地方請指出，我會修改並加以完善。