2. 程式人生 > >資料結構之 AVL樹（平衡二叉樹）（C語言實現）

資料結構之 AVL樹（平衡二叉樹）（C語言實現）

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

AVL樹（平衡二叉樹）

1. AVL樹定義和性質

AVL（Adelson-Velskii和Landis發明者的首字母）樹時帶有平衡條件的二叉查詢樹。

二叉查詢樹的效能分析：

  • 在一顆左右子樹高度平衡情況下，最優的時間複雜度為O(log2n)，這與這半查詢相同；
  • 在一個只有右子樹的二叉樹中，最差的時間複雜度會脫變為線性查詢O(n)。

由於二叉查詢樹存在以上問題，所以AVL樹通過旋轉使自身始終保持平衡狀態，因此，一顆基於二叉查詢樹的AVL樹具有如下性質：

  1. 二叉查詢樹中任何一個結點的左子樹和右子樹高度相差的絕對值最多為1。
  2. 它的左、右子樹也分別都是平衡二叉樹。

這裡寫圖片描述

如果往上圖左邊的AVL樹插入結點6，那麼該樹就會破壞結點8的平衡條件（如下圖），為了恢復AVL樹的性質，介紹修正的方法：旋轉（rotation）

。

這裡寫圖片描述

2. 旋轉

當AVL樹的平衡被破壞時，我們將必須重新平衡的結點稱為α（剛才由於插入結點6而必須重新平衡的結點8）。這種不平衡出現在下面的四種情況：

  1. 對α的左兒子的左子樹進行一次插入。
  2. 對α的左兒子的右子樹進行一次插入。
  3. 對α的右兒子的左子樹進行一次插入。
  4. 對α的右兒子的右子樹進行一次插入。

上述四種情況，理論上只有兩種情況，但是程式設計角度還是四種情形。

  • 情形1和4時關於α映象對稱（即左 - 左或右 - 右情況），因此該情況通過對樹進行一次單旋轉（single rotation）而完成調整；
  • 情形2和3時關於α映象對稱（即左 - 右或右 - 左情況），因此該情形通過雙旋轉（double rotation）
    來處理。

2.1單旋轉

下圖顯示單旋轉如何調整情況1（左 - 左情況）。虛線表示樹的各層
這裡寫圖片描述

如左圖所示：k2節點不滿足AVL的平衡條件，因為它的左子樹比右子樹深兩層。

為了恢復平衡，就必須將k1子樹整體上移作為根節點（因為k1子樹深），k2子樹整體下沉（因為k2子樹淺），成為k1的右孩子。同時必須滿足二叉查詢樹的左子樹必須小於右子樹的性質，將Y節點作為k2的左孩子。至此，單旋轉完成調整，X，Y，Z處於同一層。

將之前插入節點6而造成節點8不平衡的情況，通過單旋轉實現平衡（通過改變結點的孩子指標）。如下圖：

這裡寫圖片描述

由於情形4（右 - 右）與情況1（左 - 左）時映象對稱的，因此，和理解上述單旋轉修復情況1的方法類似。

這裡寫圖片描述

k1結點不滿足平衡條件。將k2結點上提，k1結點下沉，同時滿足左孩子小於右孩子的性質，即可完成修復情況4。

接下來，演示一個長一點的單旋轉的例子：

  • 初始的空AVL樹插入關鍵字3、2和1，此時根節點已經被破壞平衡，屬於（左 - 左）情況，因此通過單旋轉調整。

這裡寫圖片描述

  • 繼續插入4和5，插入5之後，結點3又被破壞平衡，屬於（右 - 右）情況，通過單旋轉調整。

這裡寫圖片描述

  • 繼續插入6，根節點的平衡被破壞，屬於（右 - 右）情況，通古單旋轉調整。

這裡寫圖片描述

  • 繼續插入7，結點5平衡被破壞，屬於（右 - 右）情況，通過單旋轉調整。

這裡寫圖片描述

2.2雙旋轉

單旋轉可以調整情況1和4，但是對於2和3，並不能修復AVL樹的性質（如下圖），k1的左右子樹的深度仍然為2。

這裡寫圖片描述

2和3情況是（左 - 右）和（右 - 左）的情形，因此通過雙旋轉來修復AVL樹的性質。

情形2:對α的 左兒子的右子樹 進行一次插入。
情形3:對α的 右兒子的左子樹 進行一次插入。

通過雙旋轉修復情形2，如下圖所示：

這裡寫圖片描述

如圖所示，第一次，先將k1作為根節點，以k1、k2和C為路徑，以（右 - 右）方式通過單旋轉調整，第二次，以k3為根節點，以k3、k2和k1為路徑，以（左 - 左）方式 通過單旋轉調整如右上圖所示。將最深的節點，提高到根節點，以達到平衡的性質。

因此，一次雙旋轉可以看成兩次單旋轉。

我們在剛才的例子上繼續插入節點，直觀的感受雙旋轉。繼續插入16和15結點，此時7的平衡被破壞。

這裡寫圖片描述

此時的情形是（右 - 左）型別。通過一次雙旋轉，將最深的15旋轉到了被破壞平衡的節點位置。繼續插入14，6的平衡又被破壞。

這裡寫圖片描述
此時屬於（右 - 左）型別。通過一次雙旋轉，將7旋轉到了被破壞平衡的節點位置。繼續插入13，導致根節點4平衡被破壞。

這裡寫圖片描述

此時屬於（右 - 右）型別，通過一次單旋轉，將7節點旋轉到根節點，恢復平衡的性質。繼續插入12,節點15平衡被破壞。

這裡寫圖片描述

此時屬於（左 - 左）型別。通過一側單旋轉。恢復平衡性質。繼續插入11，還需要進行一個單旋轉，對其後的10的插入也需要單旋轉，然後插入8不需要旋轉，這樣就建立了一顆近乎理想的平衡樹。

這裡寫圖片描述
最後插入9，需要進行一次雙旋轉，就能得到下面的樹。

這裡寫圖片描述

根據以上過程，就可以得到程式設計的細節：

  • 插入：為了將關鍵字是X的新節點插入到一顆AVL樹中，遞迴的將X插入到T的相應的子樹中。如果子樹高度不變，則插入完成，如果在T中出現高度不平衡，那麼根據X和子樹中的關鍵字做適當的單旋轉或雙旋轉，跟新這些高度，從而完成插入。
  • 刪除：刪除則要比插入更加複雜，遞迴尋找要刪除的關鍵字，分有一個或零個孩子和有兩個孩子的情況，分別去刪除，每次刪除完都要判斷是否平衡，不平衡，通過旋轉修正。

AVL樹的實現

  • AVLtree.h檔案
#ifndef _SEARCHTREE_H_
#define _SEARCHTREE_H_

#define MAX(a, b)   (a > b ? a : b)
#define GET_HEIGHT(T)   (T == NULL ? -1 : T->height)    //獲得樹的高度

typedef int myType;

typedef struct treeNode 
{
    myType element;
    struct treeNode *lchild;
    struct treeNode *rchild;
    int height;     //儲存樹的高度資訊
}AVLtree;

void preOrder(AVLtree *T);
void inOrder(AVLtree *T);
void postOrder(AVLtree *T);
void levelOrder(AVLtree *T);
AVLtree *find(myType data, AVLtree *T);
AVLtree *findMin(AVLtree *T);
AVLtree *findMax(AVLtree *T);
AVLtree *insert(myType data, AVLtree *T);
AVLtree *erase(myType data, AVLtree *T);

#endif
  • AVLtree.c檔案
#include <stdio.h>
#include <stdlib.h>
#include "AVLtree.h"
#include "queue.h"      //水平遍歷時需要佇列資料結構

AVLtree *find(myType data, AVLtree *T)
{
    if(T == NULL) 
        return NULL;
    if(data < T->element)
        return find(data, T->lchild);
    else if(data > T->element)
        return find(data, T->rchild);
    else 
        return T;
}

AVLtree *findMin(AVLtree *T)
{
    if(T == NULL) 
        return NULL;
    else if(T->lchild == NULL)
        return T;
    else 
        return findMin(T->lchild);
}
AVLtree *findMax(AVLtree *T)
{
    if(T != NULL) 
        while(T->rchild != NULL)
            T = T->rchild;
    return T;

}

static int getHeight(AVLtree *T)
{
    return GET_HEIGHT(T);
}

static AVLtree *singleRotateWithLeft(AVLtree *T)
{
    AVLtree *TT;

    TT = T->lchild;
    T->lchild = TT->rchild;
    TT->rchild = T;

    T->height = MAX(getHeight(TT->lchild), getHeight(T->rchild)) + 1;
    TT->height = MAX(getHeight(TT->lchild), T->height) + 1;

    return TT;
}

static AVLtree *singleRotateWithRight(AVLtree *T)
{
    AVLtree *TT;

    TT = T->rchild;
    T->rchild = TT->lchild;
    TT->lchild = T;

    T->height = MAX(getHeight(TT->lchild), getHeight(T->rchild)) + 1;
    TT->height = MAX(getHeight(TT->lchild), T->height) + 1;

    return TT;
}

static AVLtree *doubleRotateWithLeft(AVLtree *T)
{
    T->lchild = singleRotateWithRight(T->lchild);

    return singleRotateWithLeft(T);
}

static AVLtree *doubleRotateWithRight(AVLtree *T)
{
    T->rchild = singleRotateWithLeft(T->rchild);

    return singleRotateWithRight(T);
}

AVLtree *insert(myType data, AVLtree *T)
{
    if(T == NULL) {
        T = (AVLtree *)malloc(sizeof(struct treeNode));
        T->element = data;
        T->lchild = NULL;
        T->rchild = NULL;
        T->height = 0;
    } else if (data < T->element) {
        T->lchild = insert(data, T->lchild);    
        if(GET_HEIGHT(T->lchild) - GET_HEIGHT(T->rchild) == 2)
            if(data < T->lchild->element)
                T = singleRotateWithLeft(T);
            else 
                T = doubleRotateWithLeft(T);
    } else if (data > T->element) {
        T->rchild = insert(data, T->rchild);    
        if(GET_HEIGHT(T->rchild) - GET_HEIGHT(T->lchild) == 2)
            if(data > T->rchild->element)
                T = singleRotateWithRight(T);
            else 
                T = doubleRotateWithRight(T);
    }

    T->height = MAX(getHeight(T->lchild), getHeight(T->rchild) + 1);

    return T;
}
AVLtree *erase(myType data, AVLtree *T)
{
    AVLtree *tmpNode;

    if(T == NULL) {
        printf("NOT FOUNT\n");
    } else if (data < T->element) {
        T->lchild = erase(data, T->lchild); 
        if(getHeight(T->rchild) - getHeight(T->lchild) == 2) {
            AVLtree *tmp = T->rchild;
            if(getHeight(tmp->lchild) > getHeight(tmp->rchild))
                T = doubleRotateWithRight(T);
            else
                T = singleRotateWithRight(T);
        }
    } else if (data > T->element) {
        T->rchild = erase(data, T->rchild);
        if(getHeight(T->lchild) - getHeight(T->rchild) == 2) {
            AVLtree *tmp = T->lchild;
            if(getHeight(tmp->rchild) > getHeight(tmp->lchild))
                T = doubleRotateWithLeft(T);
            else
                T = singleRotateWithLeft(T);
        }
    //found element to delete, two children
    } else if (T->lchild && T->rchild){
        if(getHeight(T->rchild) > getHeight(T->lchild)) {
            tmpNode = findMin(T->rchild);//將右子樹的最小值代替root
            T->element = tmpNode->element;
            T->rchild = erase(T->element, T->rchild);
        } else {
            tmpNode = findMax(T->lchild);//將左子樹的最大值代替root   
            T->element = tmpNode->element;
            T->lchild = erase(T->element, T->lchild);
        }
    } else {
        //one or zero children
        tmpNode = T;    
        T = (T->lchild == NULL ? T->rchild : T->lchild);
        free(tmpNode);
    }   

    return T;
}

void levelOrder(AVLtree *T)
{
    QUEUE *q = createQueue(100);

    while(T != NULL) {
        printf("%d ", T->element);  
        if(T->lchild != NULL) 
            enQueue(T->lchild, q);  
        if(T->rchild != NULL)
            enQueue(T->rchild, q);

        if(!isEmpty(q))
            T = frontAndDequeue(q);
        else
            T = NULL;
    }

    disposeQueue(q);
}

void preOrder(AVLtree *T)
{
    if(T != NULL) {
        printf("%d ", T->element);  
        preOrder(T->lchild);
        preOrder(T->rchild);
    }
}

void inOrder(AVLtree *T)
{
    if(T != NULL) {
        inOrder(T->lchild); 
        printf("%d ", T->element);  
        inOrder(T->rchild);
    }
}
void postOrder(AVLtree *T)
{
    if(T != NULL) {
        postOrder(T->lchild);   
        postOrder(T->rchild);
        printf("%d ", T->element);  
    }
}

本文參考：《資料結構與演算法分析：C語言實現》——Mark Allen Weiss (維斯)

相關推薦

資料結構與算法系列----平衡二叉樹（AVL樹）

一：背景 平衡二叉樹（又稱AVL樹）是二叉查詢樹的一個進化體，由於二叉查詢樹不是嚴格的O(logN)，所以引入一個具有平衡概念的二叉樹，它的查詢速度是O(logN)。所以在學習平衡二叉樹之前，讀者必須需要了解下二叉查詢樹，具體連結：二叉查詢樹 那麼平衡是什麼意思？我們要求

資料結構之自建演算法庫——二叉樹的鏈式儲存及基本運算

                     二叉樹的鏈式儲存演算法庫採用程式的多檔案組織形式，包括兩個檔案：  　　  　　1.標頭檔案：btree.h，包含定義二叉樹的鏈式儲存資料結構的程式碼、巨集定義、要實現演算法的函式的宣告；#ifndef BTREE_H_INCLUDED#define BTREE_H_

Java資料結構之 AVL樹（平衡二叉樹）簡析

AVL（即平衡二叉樹）樹是帶有平衡條件的二叉查詢樹（二叉查詢樹即左孩子小於根節點，右孩子大於根節點的二叉樹）。一顆AVL樹是其每個節點的左子樹和右子樹的高度最多差 1 的二叉查詢樹（空樹的高度定為-1），只有一個節點的樹高度為0。在高度為h的AVL樹中，最少節點數S(h)=S

Javascript之資料結構與演算法的自平衡二叉搜尋樹（AVL）實現

Javascript之資料結構與演算法的自平衡二叉搜尋樹（AVL）實現 簡介 程式碼實現 簡介 AVL樹是一種自平衡樹。新增或移除節點時， AVL樹會嘗試自平衡。任意一個節點（不論深 度）的左子樹和右子樹高度最多相差1

資料結構之 AVL樹（平衡二叉樹）（C語言實現）

AVL樹（平衡二叉樹） 1. AVL樹定義和性質 AVL（Adelson-Velskii和Landis發明者的首字母）樹時帶有平衡條件的二叉查詢樹。 二叉查詢樹的效能分析： 在一顆左右子樹高度平衡情況下，最優的時間複雜度為O(log2n)，這與這半

資料結構（樹，二叉搜尋樹，平衡二叉樹 C++實現）

樹 樹（Tree）是n（n>=0）個結點的有限集合。n = 0時稱為空樹。在任意一顆非空樹中：(1)有且僅有一個特定的稱為根（Root）的結點；（2）當n > 1時，其餘結點可分為m （m > 0）個互不相交的有限集 T1T1 、 T2T2

Java 樹結構實際應用 四（平衡二叉樹/AVL樹）

平衡二叉樹(AVL 樹) 1 看一個案例(說明二叉排序樹可能的問題) 給你一個數列{1,2,3,4,5,6}，要求建立一顆二叉排序樹(BST), 並分析問題所在.  左邊 BST 存在的問題分析: 1) 左子樹全部為空，從形式上看，更像一個單鏈表. 2) 插入速度沒有影響 3) 查詢速度明顯降低(因為需要依

PAT 1123—— Is It a Complete AVL Tree（平衡二叉樹）【左旋右旋各種旋】

#include <cstdio> #include <algorithm> #include <vector> #include <iostream> #include <queue> using namespace std;

手動編寫AVL（平衡二叉樹），實現了基本的add、get 、remove、 toString、 contains等方法，

平衡二叉樹：是指一棵空樹或者是任意節點的左右孩子的高度相差絕對值小於等於1 package com.hcc.DStructure; import java.util.ArrayList; import java.util.concurrent.ArrayBlockingQ

資料結構--非遞迴遍歷二叉樹（利用輔助棧）

#include "StdAfx.h" #include <stdio.h> #include <stdlib.h> /*非遞迴方法前序遍歷二叉樹，利用輔助棧(指標陣列實現)。由於對指標不是很熟悉，程式碼較為混亂，基本上實現遍歷的功能。

數據結構【查找】—平衡二叉樹AVL

balance 實現 增加 調整 補充 若是 思想 基本思想 頭結點 /*自己看了半天也沒看懂代碼，下次再補充說明*/ 解釋： 　　平衡二叉樹（Self-Balancing Binary Search Tree 或Height-Balanced Binary Searc

java數據結構之三叉鏈表示的二叉樹

按層遍歷 postorder while ldl 字符串 param pub link 根節點 三叉鏈表示的二叉樹定義所畏的三叉鏈表示是指二叉樹由指向左孩子結點、右孩子結點、父親結點【三叉】的引用（指針）數據和數據組成。 package datastructure.t

資料結構__非遞迴的二叉樹後續遍歷

首先， 這篇文章講解關於二叉樹的三種遍歷 十分不錯的https://www.cnblogs.com/SHERO-Vae/p/5800363.html 特別鳴謝 @煙雨迷離半世觴 提供         一共寫了四個檔案 mai

資料結構與算法系列17--二叉樹

什麼是二叉樹？ 二叉樹是每個結點最多有兩個子樹的樹結構，它是最常見的一種樹結構。 一些基本概念 根節點：樹的最頂端是節點，如圖中的1節點 父節點：圖中1就是2和3的父節點 子節點：相對的，2和3就是子節點 兄弟節點：在同一父節點下，像2和3就是兄弟節點 葉子節點：沒有子節點的節

資料結構基礎篇-------7.1 完全二叉樹

/* * 完全二叉樹 * 2018.10.23 * @L.F * */ #include <stdio.h> #include <stdlib.h> //定義結點結構體 typedef struct node{ int id; //編

AVL樹和平衡二叉樹 平衡因子 右旋轉LL 左旋轉RR LR RL

　　前言 　　今天要介紹幾種高階資料結構AVL樹，介紹之前AVL，會先說明平衡二叉樹，並將樹的學習路線進行總結，並介紹維持平衡的方法：右旋轉、左旋轉。 　　一、樹學習路線 　　1、路線總結 　　總結了一下樹的學習路線，如下圖： 　　 　　2、說明 　　上面這個圖要從上往下進行一步一步學習；首先，

二叉樹，完全二叉樹，滿二叉樹，二叉排序樹，平衡二叉樹，紅黑樹，B數，B-樹，B+樹，B*樹（一）

二叉樹 二叉樹：二叉樹是每個節點最多有兩個子樹的樹結構； 是n(n>=0)個結點的有限集合，它或者是空樹（n=0），或者是由一個根結點及兩顆互不相交的、分別稱為左子樹和右子樹的二叉樹所組成。 完全二叉樹 完全二叉樹：除最後一層外，每一層上的結點數均達到最

二叉樹，完全二叉樹，滿二叉樹，二叉排序樹，平衡二叉樹，紅黑樹，B數，B-樹，B+樹，B*樹（二）

二叉樹，完全二叉樹，滿二叉樹，二叉排序樹，平衡二叉樹，紅黑樹，B數，B-樹，B+樹，B*樹（一）： BST樹 即二叉搜尋樹：        1.所有非葉子結點至多擁有兩個兒子（Left和Right）；        2.所有結點儲存一個關鍵字；       

AVL樹，平衡二叉樹的LL,LR ,RR,RL旋轉

////////////////////////////////////////////////////////////// ////////////建立平衡二叉樹的調整////////////@xomlee    20131227   #include <std

一步一圖一程式碼，一定要讓你真正徹底明白紅黑樹（平衡二叉樹）

一步一圖一程式碼，一定要讓你真正徹底明白紅黑樹 作者：July   二零一一年一月九日 ----------------------------- 本文參考： I、  The Art of Computer Programming Volume I II、 I