2. 程式人生 > >資料結構----AVL平衡樹----AVL平衡樹的基本操作

資料結構----AVL平衡樹----AVL平衡樹的基本操作

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

一、二叉查詢樹

我們先來講講二叉查詢樹。

大家應該聽說過二分查詢吧，二分查詢是對一個有序序列的快速查詢，時間複雜度為O(log2(n))，

但是二分查詢也有它的缺點，當序列加入一個元素時，我們就需要對這個有序序列進行維護，要麼就用sort()，要麼就用插入排序（附帶大量的資料移動），時間複雜度就會陡然提升。

於是就有了一種新的資料結構：二叉查詢樹！

二叉查詢樹的運用比較靈活，支援插入O(log2(n))、查詢O(log2(n))、刪除和前驅後繼的查詢。

插入操作：

（1）將要插入的節點與根節點比較，如果沒有根節點，則把該節點作為根節點。

（2）如果插入的節點小於根節點，就把該節點插入到左子樹，並把左

子樹的根節點作為比較物件。

（3）如果插入的節點大於根節點，就把該節點插入到右子樹，並把右子樹的根節點作為比較物件。

（4）遞迴進行以上操作，直到達到葉子節點。

（5）將它插入到葉子節點的下方。

查詢操作：

（1）將它與根節點比較，如果比根節點小，就向左子樹查詢；如果比根節點大，就向右子樹查詢。

（2）如果到了葉子節點下方還沒有找到返回-1。

（3）如果找到了，就返回該節點的下表或值。

刪除操作：

（1）找到該節點a。（最重要的一步）

（2）在這個節點的左子樹裡找到最大的節點b（即前驅）。

（3）刪掉節點b，因為節點b沒有右兒子，所以就把節點b的左子樹的根節點來代替節點b。

（4）用節點b來代替節點a。

查詢前驅與後繼操作：

（1）找到這個節點a。

（2）a的前驅為它的左子樹裡最右的兒子。

（3）a的後繼為它的右子樹裡最左的兒子。

但是，二叉查詢樹也有它的缺點，因為當輸入資料是有序的時候（如：1 2 3 4 5 6），經過插入操作之後，建成的樹為這個樣子：


之後，所有的操作的時間複雜度都變成了O(n)了，怎麼處理這樣的情況呢？

於是就有了二叉查詢樹的升級版：AVL平衡樹！

二、AVL平衡樹

AVL平衡樹其實就是在每一個節點上面加了一個平衡因子h，h表示的是以這個節點為根節點的樹總深度，當一個節點的左右兒子的平衡因子的差大於1時，就會對此進行平衡化旋轉操作。

平衡樹的定義方法：（注意maxn大小最好為輸入資料數量n的4倍，即4n）

struct node{
    int lc,rc,h,v;
}tree[maxn];

平衡化旋轉大致分為4類

1、zig旋轉：

當平衡樹中插入的節點在第一個不平衡的節點的左子樹的左子樹中，我們就要對平衡樹進行zig旋轉

程式碼：

int zig(int r)
{
    int t=tree[r].lc;
    tree[r].lc=tree[t].rc;
    tree[t].rc=r;
    tree[r].h=max(tree[tree[r].rc].h,tree[tree[r].lc].h)+1;
    tree[t].h=max(tree[tree[t].rc].h,tree[tree[t].lc].h)+1;
    return t;
}

2、zag旋轉：

當平衡樹中插入的節點在第一個不平衡的節點的右子樹的右子樹中，我們就要對平衡樹進行zag旋轉

程式碼：

int zag(int r)
{
    int t=tree[r].rc;
    tree[r].rc=tree[t].lc;
    tree[t].lc=r;
    tree[r].h=max(tree[tree[r].rc].h,tree[tree[r].lc].h)+1;
    tree[t].h=max(tree[tree[t].rc].h,tree[tree[t].lc].h)+1;
    return t;
}

3、zigzag旋轉：

當平衡樹中插入的節點在第一個不平衡的節點的左子樹的右子樹中，我們就要對平衡樹進行zigzag旋轉

程式碼：

int zigzag(int r)
{
    tree[r].rc=zig(tree[r].rc);
    return zag(r);
}

4、zagzig旋轉：

當平衡樹中插入的節點在第一個不平衡的節點的右子樹的左子樹中，我們就要對平衡樹進行zagzig旋轉

程式碼：

int zagzig(int r)
{
    tree[r].lc=zag(tree[r].lc);
    return zig(r);
}

插入操作跟二叉查詢樹差不多，只不過要注意插入後的調整： 
int insert(int x,int r)
{
    if(r==0){
        tree[++cnt].v=x;
        tree[cnt].h=1;
        return cnt;
    }
    if(x<tree[r].v){
        tree[r].lc=insert(x,tree[r].lc);
        if(tree[tree[r].lc].h==tree[tree[r].rc].h+2){
            if(x<tree[tree[r].lc].v) r=zig(r);
            else if(x>tree[tree[r].lc].v) r=zagzig(r);
        }
    }
    else if(x>tree[r].v){
        tree[r].rc=insert(x,tree[r].rc);
        if(tree[tree[r].rc].h==tree[tree[r].lc].h+2){
            if(x>tree[tree[r].rc].v) r=zag(r);
            else if(x<tree[tree[r].rc].v) r=zigzag(r);
        }
    }
    tree[r].h=max(tree[tree[r].lc].h,tree[tree[r].rc].h)+1;
    return r;
}

刪除操作的思路跟二叉查詢樹的思路是一樣的，但是調整整棵樹就比較麻煩了（因為一次旋轉不能達到平衡），所以說就要寫一個maintain()函式，在每次呼叫dele()的最後都要呼叫一下maintain()。

void maintain(int &r)
{
    if(tree[tree[r].lc].h==tree[tree[r].rc].h+2){
        int t=tree[r].lc;
        if(tree[tree[t].lc].h==tree[tree[r].rc].h+1)
           r=zig(r);
        else if(tree[tree[t].rc].h==tree[tree[r].rc].h+1){
            tree[r].lc=zag(tree[r].lc);
            r=zig(r);
        }
    }
    else if(tree[tree[r].lc].h+2==tree[tree[r].rc].h){
        int t=tree[r].rc;
        if(tree[tree[t].rc].h==tree[tree[r].lc].h+1)
            r=zag(r);
        else if(tree[tree[t].lc].h==tree[tree[r].lc].h+1){
            tree[r].rc=zig(tree[r].rc);
            r=zag(r);
        }
    }
    tree[r].h=max(tree[tree[r].lc].h,tree[tree[r].rc].h)+1;
}
int dele(int &r,int x)
{
    int tx;
    if(x==tree[r].v||(x<tree[r].v&&tree[r].lc==0)||(x>tree[r].v&&tree[r].rc==0)){
        if(tree[r].lc==0||tree[r].rc==0){
            tx=tree[r].v;
            r=tree[r].lc+tree[r].rc;
            return tx;
        }
        else
            tree[r].v=dele(tree[r].lc,x);
    }
    else{
        if(x<tree[r].v)
            tx=dele(tree[r].lc,x);
        else tx=dele(tree[r].rc,x);
    }
    maintain(r);
    return tx;
}

AVL仍然可以採用惰性刪除，對於要刪除的節點，只需要給它進行一個標記。平衡樹的高度仍然是log(N)，這樣並不會降低效率，而刪除操作卻要快速的多。

如果遇到那些刪除過後還要恢復的節點，則惰性刪除更優，不需要額外佔用空間，將原來的節點恢復即可。

如果遇到那種允許節點重複的AVL，惰性刪除更可取，將刪除標記設為整型變數，表示該節點出現的數量即可。

查詢操作和二叉查詢樹也大致相同。以下程式碼是查詢一個數在序列中與其他數的最小的差值（即最接近的數與它的差）。

int find(int root,int x)
{
    if(root==0) return 1<<30;
    if(x==tree[root].v) return 0;
    if(x>tree[root].v)
        return min(x-tree[root].v,find(tree[root].rc,x));
    else
        return min(tree[root].v-x,find(tree[root].lc,x));
}

三、例題

營業額統計

題目描述

Tiger最近被公司升任為營業部經理，他上任後接受公司交給的第一項任務便是統計並分析公司成立以來的營業情況。 Tiger拿出了公司的賬本，賬本上記錄了公司成立以來每天的營業額。分析營業情況是一項相當複雜的工作。由於節假日，大減價或者是其他情況的時候，營業額會出現一定的波動，當然一定的波動是能夠接受的，但是在某些時候營業額突變得很高或是很低，這就證明公司此時的經營狀況出現了問題。經濟管理學上定義了一種最小波動值來衡量這種情況： 該天的最小波動值 = min {該天以前某一天的營業額 - 該天營業額} 當最小波動值越大時，就說明營業情況越不穩定。 而分析整個公司的從成立到現在營業情況是否穩定，只需要把每一天的最小波動值加起來就可以了。你的任務就是編寫一個程式幫助Tiger來計算這一個值。 第一天的最小波動值為第一天的營業額。 天數小於100000.

輸入

第一行為正整數 ，表示該公司從成立一直到現在的天數

接下來的n行每行有一個整數(一定有資料小於〇) ，表示第i天公司的營業額。

輸出

輸出檔案僅有一個正整數，即每一天的最小波動值之和。答案保證在int範圍內。

樣例輸入

6
5
1
2
5
4
6

樣例輸出

12

提示

結果說明：5+|1-5|+|2-1|+|5-5|+|4-5|+|6-5|=5+4+1+0+1+1=12


四、分析

一道典型的平衡樹題目。

思路：

（1）輸入一個數a。如果a為第一個，則sum+=a，進行步驟（3）。

（2）查詢最接近a的數b與a之差，即abs(a-b)。sum+=abs(a-b)。

（3）插入a。

程式碼：

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
struct node{
    int lc,rc,h,v;
}tree[100005];
int cnt;
int zig(int r)
{
    int t=tree[r].lc;
    tree[r].lc=tree[t].rc;
    tree[t].rc=r;
    tree[r].h=max(tree[tree[r].rc].h,tree[tree[r].lc].h)+1;
    tree[t].h=max(tree[tree[t].rc].h,tree[tree[t].lc].h)+1;
    return t;
}
int zag(int r)
{
    int t=tree[r].rc;
    tree[r].rc=tree[t].lc;
    tree[t].lc=r;
    tree[r].h=max(tree[tree[r].rc].h,tree[tree[r].lc].h)+1;
    tree[t].h=max(tree[tree[t].rc].h,tree[tree[t].lc].h)+1;
    return t;
}
int zagzig(int r)
{
    tree[r].lc=zag(tree[r].lc);
    return zig(r);
}
int zigzag(int r)
{
    tree[r].rc=zig(tree[r].rc);
    return zag(r);
}
int find(int root,int x)
{
    if(root==0) return 1<<30;
    if(x==tree[root].v) return 0;
    if(x>tree[root].v)
        return min(x-tree[root].v,find(tree[root].rc,x));
    else
        return min(tree[root].v-x,find(tree[root].lc,x));
}
int insert(int x,int r)
{
    if(r==0){
        tree[++cnt].v=x;
        tree[cnt].h=1;
        return cnt;
    }
    if(x<tree[r].v){
        tree[r].lc=insert(x,tree[r].lc);
        if(tree[tree[r].lc].h==tree[tree[r].rc].h+2){
            if(x<tree[tree[r].lc].v) r=zig(r);
            else if(x>tree[tree[r].lc].v) r=zagzig(r);
        }
    }
    else if(x>tree[r].v){
        tree[r].rc=insert(x,tree[r].rc);
        if(tree[tree[r].rc].h==tree[tree[r].lc].h+2){
            if(x>tree[tree[r].rc].v) r=zag(r);
            else if(x<tree[tree[r].rc].v) r=zigzag(r);
        }
    }
    tree[r].h=max(tree[tree[r].lc].h,tree[tree[r].rc].h)+1;
    return r;
}
int main()
{
    int n,i,x,sum=0,root=0,s;
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        scanf("%d",&x);
        if(i==1){sum+=x;root=insert(x,root);continue;}
        s=find(root,x);
        if(s!=0){
            root=insert(x,root);
            sum+=abs(s);
        }
    }
    printf("%d",sum);
}

相關推薦

資料結構（一）:順序表的基本操作 C語言

順序表   標頭檔案： Sqlist.h #include<stdio.h> #include<stdlib.h> #define SIZE 15 #pragma once typedef struct Sqlist { int elem[SIZ

資料結構實驗一：線性表的基本操作

// 186658-S181-李雙源.cpp : 定義控制檯應用程式的入口點。 //時間 2018-10-27 //內容：線性表的基本操作 #include "stdafx.h" #include <iostream> #include<s

資料結構學習之路4 佇列的基本操作（順序儲存的迴圈佇列+連結串列實現）

佇列先進先出，這裡用了順序（陣列）和鏈式兩種方式實現，下次再用鏈式儲存實現以下堆疊試試 迴圈佇列： //順序儲存結構的迴圈佇列 #include<iostream> using namespace std; #define MAXSIZE 100 typedef

【資料結構】單鏈表的實現與基本操作C++

最近在複習資料結構，自己用C++寫了單鏈表這一塊的一些程式碼。 以下是帶頭結點單鏈表的建立和查詢等的程式碼。 #include <iostream> using namespace std; //單鏈表 struct LNode{ int data; st

資料結構---用順序表實現棧的基本操作

順序表實現棧    順序棧：棧的順序儲存結構,是利用一組地址連續的儲存單元依次存放自棧底到棧頂的資料元素,同時附設指標top指示棧頂元素在順序 棧中的位置。    棧在資料結構中也是一個比較重要的結構，它有一個重要的特性是：先進後出。先入棧的元素最後出棧。具

資料結構之鏈式棧的一些基本操作

鏈式棧是一種資料儲存結構，可以通過單鏈表的方式來實現，使用鏈式棧的優點在於它能夠克服用陣列實現的順序棧空間利用率不高的特點，但是需要為每個棧元素分配額外的指標空間用來存放指標域。 標頭檔案 LinkS

資料結構 線性連結串列的創立及其基本操作初始化、遍歷、銷燬、判空、求表長、刪除、插入等

最近寫了個數據結構的單鏈表，其中包括十來個基本操作演算法，包括了建立單鏈表、刪除、插入、定位、遍歷等基本的操作。在VS上運行了一下，可以通過，感覺還不錯，和大家分享一下！ 我是建立了一個C++專案，在專案下寫的，你們也可以建立專案把下面的東西複製到編譯器上試試！ 第一部分是

【資料結構】迴圈佇列的認識和基本操作

迴圈佇列初始條件:隊頭指標（front）=隊尾指標(rear)=0 迴圈佇列隊滿條件:(rear+1)%size == front        (size是順序表的最大儲存空間) 迴圈佇列空條件:隊頭指標（rear）=隊尾指標(front) 隊頭指標向前移動計算:隊頭指標=(rear+1)%size    

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

//AVL(自動平衡二叉樹) #include <stdio.h> #include <stdlib.h> typedef int ElemType; //每個結點的平均值 typedef enum {      EH = 0,      LH =

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

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

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

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

【資料結構06】二叉平衡樹（AVL樹）

目錄 一、平衡二叉樹定義 二、這貨還是不是平衡二叉樹？ 三、平衡因子 四、如何保持平衡二叉樹平衡？ 五、平衡二叉樹插入節點的四種情況 六、平衡二叉樹操作的程式碼實現

Java資料結構（十四）—— 平衡二叉樹（AVL樹）

平衡二叉樹（AVL樹） 二叉排序樹問題分析 左子樹全部為空，從形式上看更像一個單鏈表 插入速度沒有影響 查詢速度明顯降低 解決方案：平衡二叉樹 基本介紹 平衡二叉樹也叫二叉搜尋樹，保證查詢效率較高 它是一棵空樹或它的左右兩個子樹的高度差的絕對值不超過1，並且左右兩棵子樹都是一棵平衡

資料結構與演算法-二叉查詢樹平衡(DSW)

上一節探討了二叉查詢樹的基本操作，二叉查詢樹的查詢效率在理想狀態下是O(lgn)，使用該樹進行查詢總是比連結串列快得多。但是，該論點並不總是正確，因為查詢效率和二叉樹的形狀息息相關。就像這樣： 圖1-1給出了3顆二叉查詢樹，它們儲存著相同的資料，但很明顯，圖1-1(A)的樹是最好的。在最壞的情況下，圖A定

【資料結構】什麼是AVL樹

目錄 什麼是AVL樹 1. 什麼是AVL樹 2. 節點的實現 3. AVL樹的調整 3.1 LL旋轉 3.2 RR旋轉 3.3 RL旋轉 3.4

資料結構與演算法：AVL樹

AVL樹 在電腦科學中，AVL樹是最先發明的自平衡二叉查詢樹。在AVL樹中任何節點的兩個子樹的高度最大差別為1，所以它也被稱為高度平衡樹。增加和刪除可能需要通過一次或多次樹旋轉來重新平衡這個樹。AVL樹得名於它的發明者G. M. Adelson-Velsky和E. M. Landis，他們在1962年的論文《

看圖輕鬆理解資料結構與算法系列(Radix樹)

前言 推出一個新系列，《看圖輕鬆理解資料結構和演算法》，主要使用圖片來描述常見的資料結構和演算法，輕鬆閱讀並理解掌握。本系列包括各種堆、各種佇列、各種列表、各種樹、各種圖、各種排序等等幾十篇的樣子。 Radix樹 Radix樹，即基數樹，也稱壓縮字首樹，是一種提供key-value儲存查詢的資料結構。與

資料結構——4.1 二叉搜尋樹

一、二叉搜尋樹 一棵二叉樹，可以為空；如果不為空，滿足以下性質： 1）非空左子樹的所有鍵值小於其根結點的鍵值 2）非空右子樹的所有鍵值大於其根結點的鍵值 3）左右子樹都是二叉搜尋樹 二、二叉搜尋樹操作的特別函式 1、查詢 1）Find ① 查詢從根結點開始，如果樹

資料結構作業：二叉排序樹及其相關操作

寫了一個簡單的。 因為自己對泛型瞭解的還是不夠到位，所以只能寫個demo版的。 這課樹沒辦法維持平衡，希望以後學一下紅黑樹，替罪羊樹etc.   /* * 簡單的二叉查詢樹 * 沒有自帶旋轉平衡 * 寫完這個我學一下 * avl樹還有紅黑樹 */ public c

11-看圖理解資料結構與算法系列(B樹的刪除)

刪除操作 刪除操作比較複雜，主要是因為刪除的項可能在葉子節點上也可能在非葉子節點上，而且刪除後可能導致不符合B樹的規定，這裡暫且稱之為導致B樹不平衡，於是要進行一些合併、左旋、右旋等操作，使之符合B樹的規定（即讓B樹平衡）。另外，如果是刪除非葉子節點項需要先找到中序前驅來替換。 情況