C++模板實現二叉樹(六 AVL樹基礎與旋轉)

阿新 • • 發佈：2019-01-30

dsw演算法可以從全域性平衡樹,但是,往往在插入於刪除動作發生時,將隻影響樹的一部分,此時重新平衡可以只在樹的一部分進行.AVL樹要求每個節點左右子樹的高度差最大為1.平衡因子用右子樹的高度減去左子樹的高度.在AVL樹中,平衡因子應該只有-1,0,1三種選擇.只要AVL樹中任意一個節點的平衡因子小於-1或者大於1,樹就要失去平衡.
以下4種情況會導致失去平衡:

當前節點平衡因子為-1,左子節點的平衡因子為0,在左子節點的左子樹中插入節點,導致當前節點的平衡因子變為-2(左子節點-1).通過右旋轉使其恢復平衡.
當前節點平衡因子為1,右子節點的平衡因子為0,在右子節點的右子樹中插入節點,導致當前節點的平衡因子變為2(右子節點1).使用左旋轉使其恢復平衡.
當前節點平衡因子為-1,左子節點的平衡因子為0,在左子節點的右子樹中插入節點,導致當前節點的平衡因子變為-2(左子節點1).使用先左後右旋轉使其恢復平衡.
當前節點平衡因子為1,右子節點的平衡因子為0,在右子節點的左子樹中插入節點,導致當前節點的平衡因子變為2(右子節點-1).使用先右後左旋轉使其恢復平衡.(與3對稱)

核心程式碼分析:
在插入節點後,首先更新平衡因子,從插入節點往上依次更新.
碰到更新為-2或2時,即中止,準備開始進行旋轉.
如果碰到更新為0時,則中止,不需要旋轉.

資料結構上，AVLNode比BinNode需要增加平衡因子和指向父親的指標。

AVLNode的資料結構：

template <class T>
class AVLNode : public BinNode<T>
{
public:
    AVLNode();
    AVLNode(const T& data, AVLNode<T> *l = NULL, AVLNode<T> *r = NULL, AVLNode<T> *p = NULL);
    AVLNode<T>* pa;
    int balanceValue;
    AVLNode<T>* left;
    AVLNode<T 
>* right;
};

對應旋轉的程式碼如下:

template <class T, unsigned int capacity>
void BinSearchTreeAVL<T, capacity>::updateBalanceFactors(AVLNode<T>* avlNode)
{
    if (root == avlNode)
    {
        root->balanceValue = 0;
    }
    else
    {
        AVLNode<T> *pa = avlNode->pa;
        if (pa->left == avlNode)
        {
            pa->balanceValue--;
        }
        else
        {
            pa->balanceValue++;
        }
        while ((root != pa) && (pa->balanceValue != 2) && (pa->balanceValue != -2))
        {
            AVLNode<T> *curr = pa;
            pa = pa->pa;
            if (curr->balanceValue == 0)
            {
                return;       //no need to balance
            }
            else if (curr == pa->left)
            {
                pa->balanceValue--;
            }
            else
            {
                pa->balanceValue++;
            }
        }
        if ((pa->balanceValue == 2) || (pa->balanceValue == -2))
        {
            //rotation to AVL balance
            //the new insert node in right tree right
            if ((pa->balanceValue == 2) && (NULL != pa->right) && (/*static_cast<AVLNode<T>*>*/(pa->right)->balanceValue == 1))
            {
                //update balance value of pa and ch, then rotation left, last update fa pointer
                pa->balanceValue = 0;
                /*static_cast<AVLNode<T>*>*/(pa->right)->balanceValue = 0;
                AVLNode<T>* grNode = pa->pa;
                AVLNode<T>* paNode = pa;
                AVLNode<T>* chNode = /*static_cast<AVLNode<T>*>*/(pa->right);
                AVLNode<T>* chLNode = chNode->left;
                rotationLeft(grNode, paNode, chNode);
                paNode->pa = chNode;
                chNode->pa = grNode;
                if (NULL != chLNode)
                {
                    chLNode->pa = paNode;
                }
            }
            //the new insert node in right tree left
            else if ((pa->balanceValue == 2) && (NULL != pa->right) && (/*static_cast<AVLNode<T>*>*/(pa->right)->balanceValue == -1))
            {
                AVLNode<T>* rotationRGrNode = pa;
                AVLNode<T>* rotationRPaNode = /*static_cast<AVLNode<T>*>*/(pa->right);
                AVLNode<T>* rotationRChNode = /*static_cast<AVLNode<T>*>*/(pa->right->left);
                int rotationRChNodeBalanceValue = rotationRChNode->balanceValue;
                AVLNode<T>* rotationRChRChNode = /*static_cast<AVLNode<T>*>*/(pa->right->left->right);
                rotationRight(rotationRGrNode, rotationRPaNode, rotationRChNode);
                rotationRChNode->pa = rotationRGrNode;
                rotationRPaNode->pa = rotationRChNode;
                if (NULL != rotationRChRChNode)
                {
                    rotationRChRChNode->pa = rotationRPaNode;
                }
                AVLNode<T>* rotationLGrNode = rotationRGrNode->pa;
                AVLNode<T>* rotationLPaNode = rotationRGrNode;
                AVLNode<T>* rotationLChNode = rotationRChNode;
                AVLNode<T>* rotationLChLChNode = /*static_cast<AVLNode<T>*>*/(rotationLChNode->left);
                rotationLeft(rotationLGrNode, rotationLPaNode, rotationLChNode);
                rotationLChNode->pa = rotationLGrNode;
                rotationLPaNode->pa = rotationLChNode;
                if (NULL != rotationLChLChNode)
                {
                    rotationLChLChNode->pa = rotationLPaNode;
                }
                if (1 == rotationRChNodeBalanceValue)
                {
                    rotationRGrNode->balanceValue = -1;
                    rotationRPaNode->balanceValue = 0;
                    rotationRChNode->balanceValue = 0;
                }
                else if (-1 == rotationRChNodeBalanceValue)
                {
                    rotationRGrNode->balanceValue = 0;
                    rotationRPaNode->balanceValue = 1;
                    rotationRChNode->balanceValue = 0;
                }
                else
                {
                    rotationRGrNode->balanceValue = 0;
                    rotationRPaNode->balanceValue = 0;
                    rotationRChNode->balanceValue = 0;
                }

            }
            //the new insert node in left tree left
            else if ((pa->balanceValue == -2) && (NULL != pa->left) && (/*static_cast<AVLNode<T>*>*/(pa->left)->balanceValue == -1))
            {
                //update balance value of pa and ch, then rotation right, last update fa pointer
                /*static_cast<AVLNode<T>*>*/(pa->left)->balanceValue = 0;
                pa->balanceValue = 0;
                AVLNode<T>* grNode = pa->pa;
                AVLNode<T>* paNode = pa;
                AVLNode<T>* chNode = /*static_cast<AVLNode<T>*>*/(pa->left);
                AVLNode<T>* chRNode = chNode->right;
                rotationRight(grNode, paNode, chNode);
                paNode->pa = chNode;
                chNode->pa = grNode;
                if (NULL != chRNode)
                {
                    chRNode->pa = paNode;
                }

            }
            //the new insert node in left tree right
            else if ((pa->balanceValue == -2) && (NULL != pa->left) && (pa->left->balanceValue == 1))          
            {
                AVLNode<T>* rotationLGrNode = pa;
                AVLNode<T>* rotationLPaNode = /*static_cast<AVLNode<T>*>*/(pa->left);
                AVLNode<T>* rotationLChNode = /*static_cast<AVLNode<T>*>*/(pa->left->right);
                int rotationLChNodeBalanceValue = rotationLChNode->balanceValue;
                AVLNode<T>* rotationLChLChNode = /*static_cast<AVLNode<T>*>*/(pa->left->right->left);
                rotationLeft(rotationLGrNode, rotationLPaNode, rotationLChNode);
                rotationLChNode->pa = rotationLGrNode;
                rotationLPaNode->pa = rotationLChNode;
                if (NULL != rotationLChLChNode)
                {
                    rotationLChLChNode->pa = rotationLPaNode;
                }
                AVLNode<T>* rotationRGrNode = rotationLGrNode->pa;
                AVLNode<T>* rotationRPaNode = rotationLGrNode;
                AVLNode<T>* rotationRChNode = rotationLChNode;
                AVLNode<T>* rotationRChRChNode = /*static_cast<AVLNode<T>*>*/(rotationRChNode->right);
                rotationRight(rotationRGrNode, rotationRPaNode, rotationRChNode);
                rotationRChNode->pa = rotationRGrNode;
                rotationRPaNode->pa = rotationRChNode;
                if (NULL != rotationRChRChNode)
                {
                    rotationRChRChNode->pa = rotationRPaNode;
                }
                if (1 == rotationLChNodeBalanceValue)
                {
                    rotationLGrNode->balanceValue = 0;
                    rotationLPaNode->balanceValue = -1;
                    rotationLChNode->balanceValue = 0;
                }
                else if (-1 == rotationLChNodeBalanceValue)
                {
                    rotationLGrNode->balanceValue = 1;
                    rotationLPaNode->balanceValue = 0;
                    rotationLChNode->balanceValue = 0;
                }
                else
                {
                    rotationLGrNode->balanceValue = 0;
                    rotationLPaNode->balanceValue = 0;
                    rotationLChNode->balanceValue = 0;
                }
            }
            else
            {
                //should be error case
            }
        }
    }
    return;
}

C++模板實現二叉樹(六 AVL樹基礎與旋轉)

dsw演算法可以從全域性平衡樹,但是,往往在插入於刪除動作發生時,將隻影響樹的一部分,此時重新平衡可以只在樹的一部分進行.AVL樹要求每個節點左右子樹的高度差最大為1.平衡因子用右子樹的高度減去左子樹的高度.在AVL樹中,平衡因子應該只有-1,0,1三種選擇.只

C++模板實現二叉樹(五樹的平衡之dsw演算法)

二叉樹的高效查詢演算法依賴於樹的平衡.如果樹高度不平衡,二叉樹將退化成類似連結串列的效率,則二叉樹的優勢就不存在了.平衡二叉樹的dsw演算法提供了一種將二叉樹轉化成平衡二叉樹的方法. 演算法的核心思想是利用旋轉. 1.通過右旋轉生成主鏈. 2.通過左旋轉生

C語言實現二叉樹各種基本運算的演算法

包含如下函式： CreateBTree( BTNode * &b, char * str ) ：由括號表示串 str 創建二叉鏈b ； FindNode( BTNode * &b, ElemType x ) ：返回data域為 x的節

C語言實現二叉樹中統計葉子結點的個數&度為1&度為2的結點個數

演算法思想統計二叉樹中葉子結點的個數和度為1、度為2的結點個數，因此可以參照二叉樹三種遍歷演算法（先序、中序、後序）中的任何一種去完成，只需將訪問操作具體變為判斷是否為葉子結點和度為1、度為2的結點及統計操作即可。 #include <stdio.h> #include &

C語言實現二叉樹的建立&遍歷

演算法思想（重點是遞迴的使用）利用擴充套件先序遍歷序列建立二叉連結串列採用類似先序遍歷的遞迴演算法，首先讀入當前根結點的資料，如果是'.'則將當前樹根置為空，否則申請一個新結點，存入當前根結點的資料，分別用當前根結點的左子域和右子域進行遞迴呼叫，建立左、右子樹.

C語言實現二叉樹的基本操作

我在前面的部落格中講解了連結串列、棧和佇列，這些資料結構其實都是線性表，並且給出了詳細的實現。從今天開始，我們將要來學習樹，樹作為一種資料結構我們經常會用到，作為起步和基礎，我們先來實現二叉樹，也就是每個節點有不超過2個子節點的樹。對於樹的操作，最基本的建立、遍

c語言實現二叉樹的插入、查詢、刪除、列印樹

目錄：二叉樹的關鍵概念：每個節點是一個自引用結構體，形式如下： struct TreeNode { struct TreeNode *leftPtr; /* pointer to left subtree */

C語言實現二叉樹的各種遍歷及求解深度

#include<stdio.h> #include<malloc.h> #define MAXSIZE 100 typedef char dataType; //二叉樹結構 typedef struct bnode{ dataType data; struct bnode *lC

C語言實現二叉樹的插入和刪除

二叉樹的插入刪除：//首先介紹二叉樹的插入： //首先需要明白插入的規則：每個建好的結點p都需要從跟結點開始與根結點相比較資料域，如果根結點的資料域小於結點p，則接著將結點p與根結點的右子樹相比較，否則p將與根結點的左子樹相比較； //繼續往下類推，一直到最後

資料結構之---C語言實現二叉排序樹（BinarySortTree）

wechat:812716131 ------------------------------------------------------ 技術交流群請聯絡上面wechat ----------------------------------------------

C語言實現二叉排序樹

二叉排序樹的插入規則：在二叉排序樹中插入新結點，要保證插入後的二叉樹仍符合二叉排序樹的定義。插入過程：若二叉排序樹為空，則待插入結點*S作為根結點插入到空樹中；當非空時，將待插結點關鍵字S->key和樹根關鍵字t->key進行

C語言實現二叉排序樹的基本運算演算法

二叉排序樹的建立、查詢和刪除過程及其演算法設計。（1）由關鍵字序列（4,9,0,1,8,6,3,5,2,7）建立一棵二叉排序樹bt並以括號表示法輸出；（2）判斷bt是否為一棵二叉排序樹；（3）採用遞迴和非遞迴兩種方法查詢關鍵字6的節點，並輸出其查詢路徑；（4）分別刪

C++類實現二叉樹的構建和遍歷

#include<iostream> #include<fstream> #include<string.h> using namespace std; /*

c語言實現二叉樹的遍歷和建立程式（附帶註釋）

/******************************************************************/ //樹的遞迴思想，把每個節點當作是一棵樹，以後序遍歷為例 //步驟1：訪問左子樹.2訪問右子樹3.列印當前節點的值 //在節點遍歷時如果

c語言實現二叉樹（二叉連結串列）非遞迴後序遍歷

演算法思想因為後序遍歷是先訪問左子樹，再訪問右子樹，最後訪問根節點。當用棧實現遍歷時，必須分清返回根節點時，是從左子樹返回的還是從右子樹返回的。所以使用輔助指標r指向最近已訪問的結點。當然也可以在節點中增加一個標誌域，記錄是否已被訪問。 #include<iost

C語言實現二叉樹的基本操作---建立、遍歷、求深度、求葉子結點

#include <stdio.h> #include <stdlib.h> #include <malloc.h> typedefint ElemType;//資料型別 //定義二叉樹結構，與單鏈表相似，多了一個右孩子結點 typed

使用C++陣列實現二叉樹的儲存和基本操作

1、建立檔案ArrayTree.h 定義二叉樹的資料結構 #ifndef ARRAYTREE_H #define ARRAYTREE_H class ArrayTree{ public: Ar

c語言實現二叉樹的基本操作--二叉連結串列儲存

利用二叉連結串列儲存，並且利用遞迴的方法實現二叉樹的遍歷（前序遍歷、中序遍歷和後續遍歷）操作。 c語言具體實現程式碼如下： #include<stdio.h> #include<stdlib.h> #include<malloc.h>

c語言實現二叉樹常用演算法

構造二叉樹結點結構 typedef struct BT { char data; struct BT *l_chrild; struct BT *r_chrild; }BT; 建立二叉樹 BT* Create_tree()//

c語言實現二叉樹的先序遍歷，中序遍歷，後序遍歷

// new.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <MEMORY.H> #include <STRING.H&

C++模板實現二叉樹(六 AVL樹基礎與旋轉)

相關推薦