平衡樹初階——AVL平衡二叉查找樹+三大平衡樹（Treap + Splay + SBT）模板【超詳解】

平衡樹初階——AVL平衡二叉查找樹

 

一、什么是二叉樹

 

1. 什么是樹。

計算機科學里面的樹本質是一個樹狀圖。樹首先是一個有向無環圖，由根節點指向子結點。但是不嚴格的說，我們也研究無向樹。所謂無向樹就是將有向樹的所有邊看成無向邊形成的樹狀圖。樹是一種遞歸的數據結構，所以我們研究樹也是按照遞歸的方式去研究的。

 

2.什么是二叉樹。

我們給出二叉樹的遞歸定義如下：

（1）空樹是一個二叉樹。

（2）單個節點是一個二叉樹。

（3）如果一棵樹中，以它的左右子節點為根形成的子樹都是二叉樹，那么這棵樹本身也是二叉樹。

 

二、BST

1.什么是二叉排序樹。

二叉排序樹是一種二叉樹，它滿足樹的中序遍歷是有序的。

 

2.BST（Binary Search Tree）。

二叉查找樹是一種最普通的二叉排序樹，一般稱作BST，也稱為B-樹。在這棵樹中，滿足在任意一個子樹中，都滿足左子樹 < 根節點 < 右子樹，即該樹的中序遍歷滿足從小到大排序的結果。

 

3.如何構造一個二叉排序樹？

很顯然，要想構造一個BST，就必須在插入節點時，滿足下面的原則：

（1）如果節點為空，則直接插入到該節點。

（2）如果節點不為空，且要插入的值小於等於當前節點的值，那么則將該節點插入到左子樹當中。

（3）如果節點不為空，且要插入的值大於當前節點的值，那么則將該節點插入到右子樹當中。

 

4.利用BST的性質對一個數組進行剃重。

由於BST有二叉排序樹的性質，我們可以利用這樣的性質對一個待定數組進行剃重。原理很簡單，只需要在插入的時候如果已經發現了相等的節點的話，那么則不進行插入即可。也就是說，只有該樹沒有的節點，我們才進行相應的插入操作。

 

 

 

三、BST的相關操作

 

1.建樹（createTree）

BST的建立是基於一個數組進行的，本質上是把數組中的數按順序插入的樹中。可以想象，，每插入一個數，平均時間復雜度為O(logn)，所以建樹的平均時間復雜度為O(nlogn)。

 

2.查找某一個值d（searchTree）

如果我們需要在BST上查找一個值d，那么我們需要從根節點開始，按照下面的思路進行遞歸查詢：

（1）如果當前節點為空，則未找到，返回NULL。

（2）如果當前節點不為空，且當前節點的值等於d，那么則找到，返回當前節點。

（3）如果當前節點不為空，且當前節點的值大於d，那么則遞歸在左子樹中尋找。

（4）如果當前節點不為空，且當前節點的值小於d，那么則遞歸在右子樹中尋找。

可以想象，查找操作的平均時間復雜度為O(logn)

 

3.刪除一個值d（deleteTree）

如果我們想要刪除一個值d的節點，那么顯然首先需要找到該節點。如果沒有找到，則刪除操作失敗，如果找到，繼續下面的操作即可：

（1）如果找到的節點的右子樹為空，那么直接用該節點的左節點替換當前節點即可。

（2）如果找到的節點的右子樹不為空，且右子樹的左子樹不為空，則遞歸找該右子樹的左子樹。

（3）如果找到的節點的右子樹不為空，且右子樹的左子樹為空，則：

    ①如果找到的該節點的右節點為空，則返回當前節點，用這個節點去替換需要刪除的點即可。

    ②如果找到的該節點的右子樹不為空，則首先用該右子樹替換找到的節點，在用找到的節點替換需要刪除的節點即可。

顯然，刪除操作的平均時間復雜度為O(logn)

 

四、AVL平衡二叉查找樹

1.什么是平衡二叉樹。

平衡二叉樹是一種二叉排序樹，並且滿足樹中任意一個節點的左右子樹的高度保持平衡。

 

2.什么是AVL。

AVL是一種二叉查找樹，並且滿足樹中任意一個節點的左右子樹的高度差的絕對值小於等於1，即保持平衡系數不大於1。AVL也稱B-BST（Balanced - Binary Search Tree），而AVL的名稱只是與這種數據結構的作者有關。

 

3.引例：為什么會產生AVL

我們為什么需要研究AVL，換句話說，為什么我們要重視BST的平衡性能呢？我們看下面的一個例子。

我們用1,2,3,4,5,6,7,8,9來進行建樹。我們發現，這樣建樹的結果如下：

 

 

可以看出，這樣二叉樹實際上退化為了一個鏈表。在最壞的情況下，插入和刪除的時間復雜度都退化為了O(n)。

很顯然，樹的平衡性越好，這種退化越不明顯。所以為了保持BST的高效，我們研究AVL是必要的。

 

4.如何保持AVL的平衡？

既然要保持左右子樹高度差小於等於1，那么我們一定需要在節點里面定義一個新的屬性，用來記錄該節點為根的樹的高度。由於建樹的過程是遞歸的，所以樹的高度的更新也是遞歸完成的。通過更新高度，我們就可以知道什么時候左右子樹的高度差大於1了，這個時候產生了失衡。一旦某一個節點開始失衡，那么這個時候必須通過旋轉操作使二叉樹達到一個新的平衡。

 

五、AVL的相關操作

1.旋轉操作（rotateAvl）

如果在某一個時刻二叉樹發生了失衡，我們就需要對二叉樹進行相應的旋轉使得二叉樹重新達到平衡。這個旋轉並不是隨意的，我們還要保證BST的基本性質，那就是中序遍歷必須有序才行。

我們總結二叉樹失衡的原因，可以歸納為以下四種情況（其中圓形節點代表失衡有關的節點，方形節點代表子樹）

 

 

歸納后發現，對於情況（1）（2），都是由於左子樹高度大於右子樹高度形成的失衡。對於情況（3）（4）則是相反的情況。且情況（1）（3）互為鏡像，情況（2）（4）互為鏡像。所以我們只以（1）（2）種情況作為例子，（3）（4）情況的道理同出一轍。

 

對於情況（1），左子樹高度大於右子樹高度，而在左子樹中，依然是左子樹高度大於右子樹高度。對於這樣的情況，我們需要以1為根進行右轉（rightRotate），右轉的結果是，2變為新的根，而1則成為2的右節點，2原本的右子樹則成為了1的左子樹，即，如下圖：

 

對於情況（2），左子樹高度大於右子樹高度，而在左子樹中，左子樹高度小於右子樹高度。對於這樣的情況，我們需要首先需要以2（leftRotate）為根進行左轉，左轉的結果是3變為1的左子樹，而2變為3的左子樹，而3原本的左子樹成了2的右子樹。如下圖所示：

 

 

之后就轉化為了情況（1），故只需要在以1為根進行右轉即可。

通過這樣的旋轉操作，AVL重新達到了平衡。

這個旋轉操作的時間復雜度是O(1)的。

 

2.高度更新操作。

由於高度更新是遞歸進行的，所以我們選擇回溯的階段進行高度更新。而一個節點的高度應該是左子樹高度和右子樹高度的最大值再加1。

高度更新在整個AVL中是必要的，不管建樹過程中，還是插入操作，或者是刪除操作中，我們都需要時時刻刻對高度進行更新，只有正確的更新高度，才能判斷二叉樹是否失衡。而一旦失衡，我們就需要進行上述的旋轉操作，這些是相輔相承的。

高度更新的時間復雜度也是O(1)的。

 

3.插入操作（insertAvl）

在插入操作中，由於插入的新節點，有可能使原本的二叉樹產生了失衡，故應該進行相應的旋轉操作。故，這樣插入操作能穩定在平均O(logn) 的時間復雜度內。

 

4.刪除操作（deleteAvl）

再刪除操作中，由於刪除了節點，也有可能是原本平衡的二叉樹產生失衡，故也應該進行相應的旋轉操作。故，這樣刪除操作能穩定在O(logn) 的時間復雜度內。

六、代碼實現（C/C++）

1.對於節點數據類型的處理：

 #define Elem int //這樣Elem就是節點中數據的類型。 

2.節點結構體的二叉鏈表

typedef struct LNode
{
    Elem data;   //節點數據域
    int height;    //節點為根的樹的高度
    struct LNode *left,*right;   //左子樹和右子樹
    struct LNode()   //構造函數
    {
        height=0;
        left=right=NULL;
    }
}LNode,*avlTree;
//這樣定義LNode是節點的類型，avlTree則是節點的指針類型。

3.右旋轉子操作，返回旋轉之后的根節點指針

avlTree _rightRotate(avlTree &r)
{
    int lh=0,rh=0;
    avlTree t=r->left;
    r->left=t->right;
    if(r->left) lh=r->left->height;
    if(r->right) rh=r->right->height;
    r->height=max(lh,rh)+1;
    t->right=r;
    if(t->left==NULL) t->height=1;
    else t->height=max(t->left->height,r->height)+1;
    return t;
}

4.左旋轉子操作，返回旋轉之后的根節點指針

avlTree _leftRotate(avlTree &r)
{
    int lh=0,rh=0;
    avlTree t=r->right;
    r->right=t->left;
    if(r->left) lh=r->left->height;
    if(r->right) rh=r->right->height;
    r->height=max(lh,rh)+1;
    t->left=r;
    if(t->right==NULL) t->height=1;
    t->height=max(t->height,r->height)+1;
    return t;
}

5.旋轉主算法（發生失衡，按照規則進行旋轉操作）

void rotateAvl(avlTree &root)
{
    int lh=0,rh=0;
    if(root->left) lh=root->left->height;
    if(root->right) rh=root->right->height;
    root->height=max(lh,rh)+1;
    if(abs(lh-rh)>1)
    {
        avlTree tp;
        int lp=0,rp=0;
        if(lh>rh) tp=root->left;
        else tp=root->right;
        if(tp->left!=NULL) lp=tp->left->height;
        if(tp->right!=NULL) rp=tp->right->height;
        if(lh>rh&&lp<rp) root->left=_leftRotate(tp);
        if(lh<rh&&lp>rp) root->right=_rightRotate(tp);
        if(lh>rh) root=_rightRotate(root);
        else root=_leftRotate(root);
    }
}

6.插入操作，向二叉樹r插入d。這里用sign標記表示是否進行剃重，如果sign為true則剃重，sign為false則表示可重復。

void insertAvl(avlTree &r,Elem d,bool sign)
{
    //遞歸出口
    if(r==NULL) {
        r=new LNode();
        r->data=d;
        r->height++;
        return;
    }
    if(d<=r->data)
    {
        if(d==r->data&&sign) return; 
        insertAvl(r->left,d,sign);
    }
    else 
    {
        insertAvl(r->right,d,sign);
    }
    rotateAvl(r);   //檢驗失衡並進行旋轉
}

7. 根據data數組建樹。這里用sign標記表示是否進行剃重，如果sign為true則剃重，sign為false則表示可重復。

void createAvl(avlTree &root,Elem data[],int n,bool sign)
{
    int i;
    root=NULL;
    for(i=0;i<n;i++)
    {
        insertAvl(root,data[i],sign);
    }
}

8.查詢root里面的數據d所在節點，如果查詢成功，則返回該節點。若d數據不存在，則查詢失敗，返回NULL。

avlTree searchAvl(avlTree root,Elem d)
{
    if(root!=NULL)
    {
        if(d==root->data) return root;
        else if(d<root->data) return searchAvl(root->left,d);
        else searchAvl(root->right,d);
    }
    return NULL;
}

9.在刪除中尋找實際需要刪除的點，返回實際點。

avlTree _delete(avlTree &root)
{
    avlTree ret=root;
    if(root->left) ret=_delete(root->left);
    else if(root->right)
    { 
        ret=root->right;
        int t=root->data;
        root->data=root->right->data;
        ret->data=t;
        root->height=1;
        root->right=NULL;
        return ret;
    }
    else
    {
        root=NULL;
        return ret;
    }
    rotateAvl(root);   //檢驗失衡並進行旋轉
    return ret;
}

10.刪除主操作算法，刪除root上的data數據所在節點

void deleteAvl(avlTree &root,Elem data)
{
    avlTree ret;
    if(!root) return;
    if(root->data!=data)   //未找到該節點，首先尋找該節點
    {
        if(data<root->data) ret=root->left;
        else ret=root->right;
        deleteAvl(ret,data);   //遞歸尋找
    }
    else     //找到該節點
    {
        if(!root->right)   //右子樹為空
        {
            root=root->left;
        }
        else   //右子樹不為空
        {
            avlTree t=_delete(root->right);   //尋找實際刪除的節點
            root->data=t->data;
            free(t);
        }
    }
    rotateAvl(root);   //檢驗失衡並進行旋轉
}

於是我又找到了一份不錯的模版總結，僅供參考！

Treap樹

核心是 利用隨機數的二叉排序樹的各種操作復雜度平均為O(lgn)

Treap模板：

#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <utility>
#include <vector>
#include <queue>
#include <map>
#include <set>
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)>(y)?(y):(x))
#define INF 0x3f3f3f3f
#define MAXN 100005

using namespace std;

int cnt=1,rt=0; //節點編號從1開始

struct Tree
{
    int key, size, pri, son[2]; //保證父親的pri大於兒子的pri
    void set(int x, int y, int z)
    {
        key=x;
        pri=y;
        size=z;
        son[0]=son[1]=0;
    }
}T[MAXN];

void rotate(int p, int &x)
{
    int y=T[x].son[!p];
    T[x].size=T[x].size-T[y].size+T[T[y].son[p]].size;
    T[x].son[!p]=T[y].son[p];
    T[y].size=T[y].size-T[T[y].son[p]].size+T[x].size;
    T[y].son[p]=x;
    x=y;
}

void ins(int key, int &x)
{
    if(x == 0)
        T[x = cnt++].set(key, rand(), 1);
    else
    {
        T[x].size++;
        int p=key < T[x].key;
        ins(key, T[x].son[!p]);
        if(T[x].pri < T[T[x].son[!p]].pri)
            rotate(p, x);
    }
}

void del(int key, int &x) //刪除值為key的節點
{
    if(T[x].key == key)
    {
        if(T[x].son[0] && T[x].son[1])
        {
            int p=T[T[x].son[0]].pri > T[T[x].son[1]].pri;
            rotate(p, x);
            del(key, T[x].son[p]);
        }
        else
        {
            if(!T[x].son[0])
                x=T[x].son[1];
            else
                x=T[x].son[0];
        }
    }
    else
    {
        T[x].size--;
        int p=T[x].key > key;
        del(key, T[x].son[!p]);
    }
}

int find(int p, int &x) //找出第p小的節點的編號
{
    if(p == T[T[x].son[0]].size+1)
        return x;
    if(p > T[T[x].son[0]].size+1)
        find(p-T[T[x].son[0]].size-1, T[x].son[1]);
    else
        find(p, T[x].son[0]);
}

int find_NoLarger(int key, int &x) //找出值小於等於key的節點個數
{
    if(x == 0)
        return 0;
    if(T[x].key <= key)
        return T[T[x].son[0]].size+1+find_NoLarger(key, T[x].son[1]);
    else
        return find_NoLarger(key, T[x].son[0]);    
}

View Code

相關題目：POJ 3481 1442 2352

Splay Tree（伸展樹）

核心就是 過程Splay(x, y)，即將x節點轉移到y節點的子節點上面（其中y是x的祖先）。

利用其中雙旋的優勢能夠保證查詢復雜度均攤為O(lgn)

一開始理解有些困難，其實實際上不做深入的理解就是，雙旋的過程就是一個建立相對平衡的二叉樹的一個過程。

》對於二叉樹，最極端的情況就是線性插入，使得整棵二叉樹退化為一條鏈。比如你查詢鏈的最后一個節點，之后再次查詢第一個節點。

1）若只是單旋通過Splay(x, 0)將最后一個節點移動到根節點，需要O(n)復雜度，而查詢第一個節點時又需要O(n)復雜度，來來往往就退化成一條鏈了。

2）若是雙旋Splay(x, 0)將最后一個節點移動到根節點上時，移動過程中建立起了相對平衡的二叉樹，需要O(n)，也就是查詢第一個節點時，大概是需要O(lgn)復雜度。這就降低了復雜度。可以證明，總的每個操作的均攤復雜度是O(lgn)。

具體證明可以參見 楊思雨《伸展樹的基本操作與應用》

I 用於維護單調隊列 ：（以key為維護對象保證單調）

常用版：（支持相同值）

 Struct Tree{

int key, size, fa, son[2];

}

void PushUp(int x);

void Rotate(int x, int p); //0左旋 1右旋

void Splay(int x, int To) //將x節點插入到To的子節點中

int find(int key) //返回值為key的節點 若無返回0 若有將其轉移到根處

int prev() //返回比根值小的最大值 若無返回0 若有將其轉移到根處

int succ() //返回比根值大的最小值 若無返回0 若有將其轉移到根處

void Insert(int key) //插入key 並且將該節點轉移到根處

void Delete(int key) //刪除值為key的節點 若有重點只刪其中一個 x的前驅移動到根處

int GetPth(int p) //獲得第p小的節點 並將其轉移到根處

int GetRank(int key) //獲得值<=key的節點個數 並將其轉移到根處 若<key只需將<=換為<

模板：

int cnt=1, rt=0;

struct Tree
{
    int key, size, fa, son[2];
    void set(int _key, int _size, int _fa)
    {
        key=_key;
        size=_size;
        fa=_fa;
        son[0]=son[1]=0;
    }
}T[MAXN];

inline void PushUp(int x)
{
    T[x].size=T[T[x].son[0]].size+T[T[x].son[1]].size+1;
}

inline void Rotate(int x, int p) //0左旋 1右旋
{
    int y=T[x].fa;
    T[y].son[!p]=T[x].son[p];
    T[T[x].son[p]].fa=y;
    T[x].fa=T[y].fa;
    if(T[x].fa)
        T[T[x].fa].son[T[T[x].fa].son[1] == y]=x;
    T[x].son[p]=y;
    T[y].fa=x;
    PushUp(y);
    PushUp(x);
}

void Splay(int x, int To) //將x節點插入到To的子節點中
{
    while(T[x].fa != To)
    {
        if(T[T[x].fa].fa == To)
            Rotate(x, T[T[x].fa].son[0] == x);
        else
        {
            int y=T[x].fa, z=T[y].fa;
            int p=(T[z].son[0] == y);
            if(T[y].son[p] == x)
                Rotate(x, !p), Rotate(x, p); //之字旋
            else
                Rotate(y, p), Rotate(x, p); //一字旋
        }
    }
    if(To == 0) rt=x;
}

int find(int key) //返回值為key的節點 若無返回0 若有將其轉移到根處
{
    int x=rt;
    while(x && T[x].key != key)
        x=T[x].son[key > T[x].key];
    if(x) Splay(x, 0);
    return x;
}

int prev() //返回比根值小的最大值 若無返回0 若有將其轉移到根處
{
    int x=T[rt].son[0];
    if(!x) return 0;
    while(T[x].son[1])
        x=T[x].son[1];
    Splay(x, 0);
    return x;
}

int succ() //返回比根值大的最小值 若無返回0 若有將其轉移到根處
{
    int x=T[rt].son[1];
    if(!x) return 0;
    while(T[x].son[0])
        x=T[x].son[0];
    Splay(x, 0);
    return x;
}

void Insert(int key) //插入key 並且將該節點轉移到根處
{
    if(!rt)
        T[rt = cnt++].set(key, 1, 0);
    else
    {
        int x=rt, y=0;
        while(x)
        {
            y=x;
            x=T[x].son[key > T[x].key];
        }
        T[x = cnt++].set(key, 1, y);
        T[y].son[key > T[y].key]=x;
        Splay(x, 0);
    }
}

void Delete(int key) //刪除值為key的節點 若有重點只刪其中一個 x的前驅移動到根處
{
    int x=find(key);
    if(!x) return;
    int y=T[x].son[0];
    while(T[y].son[1])
        y=T[y].son[1];
    int z=T[x].son[1];
    while(T[z].son[0])
        z=T[z].son[0];
    if(!y && !z)
    {
        rt=0;
        return;
    }
    if(!y)
    {
        Splay(z, 0);
        T[z].son[0]=0;
        PushUp(z);
        return;
    }
    if(!z)
    {
        Splay(y, 0);
        T[y].son[1]=0;
        PushUp(y);
        return;
    }
    Splay(y, 0);
    Splay(z, y);
    T[z].son[0]=0;
    PushUp(z);
    PushUp(y);
}

int GetPth(int p) //獲得第p小的節點 並將其轉移到根處
{
    if(!rt) return 0;
    int x=rt, ret=0;
    while(x)
    {
        if(p == T[T[x].son[0]].size+1)
            break;
        if(p>T[T[x].son[0]].size+1)
        {
            p-=T[T[x].son[0]].size+1;
            x=T[x].son[1];
        }
        else
            x=T[x].son[0];
    }
    Splay(x, 0);
    return x;
}

int GetRank(int key) //獲得值<=key的節點個數 並將其轉移到根處 若<key只需將<=換為<
{
    if(!rt) return 0;
    int x=rt, ret=0, y;
    while(x)
    {
        y=x;
        if(T[x].key <= key)
        {
            ret+=T[T[x].son[0]].size+1;
            x=T[x].son[1];
        }
        else
            x=T[x].son[0];
    }
    Splay(y, 0);
    return ret;
}

View Code

完全版：（支持相同值，支持區間刪除，支持懶惰標記）

 Struct Tree{

int key, num, size, fa, son[2];

}

void PushUp(int x);

void PushDown(int x);

int Newnode(int key, int fa); //新建一個節點並返回

void Rotate(int x, int p); //0左旋 1右旋

void Splay(int x, int To); //將x節點移動到To的子節點中

int GetPth(int p, int To); //返回第p小的節點 並移動到To的子節點中

int Find(int key); //返回值為key的節點 若無返回0 若有將其轉移到根處

int Prev(); //返回根節點的前驅

int Succ(); //返回根結點的后繼

void Insert(int key); //插入key值

void Delete(int key); //刪除值為key的節點

int GetRank(int key); //獲得值<=key的節點個數

void Delete(int l, int r); //刪除值在[l, r]中的節點 

模板：

int cnt, rt;
int Add[MAXN];

struct Tree{
    int key, num, size, fa, son[2];
}T[MAXN];

inline void PushUp(int x)
{
    T[x].size=T[T[x].son[0]].size+T[T[x].son[1]].size+T[x].num;
}

inline void PushDown(int x)
{
    if(Add[x])
    {
        if(T[x].son[0])
        {
            T[T[x].son[0]].key+=Add[x];
            Add[T[x].son[0]]+=Add[x];
        }
        if(T[x].son[1])
        {
            T[T[x].son[1]].key+=Add[x];
            Add[T[x].son[1]]+=Add[x];
        }
        Add[x]=0;
    }
}

inline int Newnode(int key, int fa) //新建一個節點並返回
{
    ++cnt;
    T[cnt].key=key;
    T[cnt].num=T[cnt].size=1;
    T[cnt].fa=fa;
    T[cnt].son[0]=T[cnt].son[1]=0;
    return cnt;
}

inline void Rotate(int x, int p) //0左旋 1右旋
{
    int y=T[x].fa;
    PushDown(y);
    PushDown(x);
    T[y].son[!p]=T[x].son[p];
    T[T[x].son[p]].fa=y;
    T[x].fa=T[y].fa;
    if(T[x].fa)
        T[T[x].fa].son[T[T[x].fa].son[1] == y]=x;
    T[x].son[p]=y;
    T[y].fa=x;
    PushUp(y);
    PushUp(x);
}

void Splay(int x, int To) //將x節點移動到To的子節點中
{
    while(T[x].fa != To)
    {
        if(T[T[x].fa].fa == To)
            Rotate(x, T[T[x].fa].son[0] == x);
        else
        {
            int y=T[x].fa, z=T[y].fa;
            int p=(T[z].son[0] == y);
            if(T[y].son[p] == x)
                Rotate(x, !p), Rotate(x, p); //之字旋
            else
                Rotate(y, p), Rotate(x, p); //一字旋
        }
    }
    if(To == 0) rt=x;
}

int GetPth(int p, int To) //返回第p小的節點 並移動到To的子節點中
{
    if(!rt || p > T[rt].size) return 0;
    int x=rt;
    while(x)
    {
        PushDown(x);
        if(p >= T[T[x].son[0]].size+1 && p <= T[T[x].son[0]].size+T[x].num)
            break;
        if(p > T[T[x].son[0]].size+T[x].num)
        {
            p-=T[T[x].son[0]].size+T[x].num;
            x=T[x].son[1];
        }
        else
            x=T[x].son[0];
    }
    Splay(x, 0);
    return x;
}

int Find(int key) //返回值為key的節點 若無返回0 若有將其轉移到根處
{
    if(!rt) return 0;
    int x=rt;
    while(x)
    {
        PushDown(x);
        if(T[x].key == key) break;
        x=T[x].son[key > T[x].key];
    }
    if(x) Splay(x, 0);
    return x;
}

int Prev() //返回根節點的前驅 非重點
{
    if(!rt || !T[rt].son[0]) return 0;
    int x=T[rt].son[0];
    while(T[x].son[1])
    {
        PushDown(x);
        x=T[x].son[1];
    }
    Splay(x, 0);
    return x;
}

int Succ() //返回根結點的后繼 非重點
{
    if(!rt || !T[rt].son[1]) return 0;
    int x=T[rt].son[1];
    while(T[x].son[0])
    {
        PushDown(x);
        x=T[x].son[0];
    }
    Splay(x, 0);
    return x;
}

void Insert(int key) //插入key值
{
    if(!rt)
        rt=Newnode(key, 0);
    else
    {
        int x=rt, y=0;
        while(x)
        {
            PushDown(x);
            y=x;
            if(T[x].key == key)
            {
                T[x].num++;
                T[x].size++;
                break;
            }
            T[x].size++;
            x=T[x].son[key > T[x].key];
        }
        if(!x)
            x=T[y].son[key > T[y].key]=Newnode(key, y);
        Splay(x, 0);
    }
}

void Delete(int key) //刪除值為key的節點1個
{
    int x=Find(key);
    if(!x) return;
    if(T[x].num>1)
    {
        T[x].num--;
        PushUp(x);
        return;
    }
    int y=T[x].son[0];
    while(T[y].son[1])
        y=T[y].son[1];
    int z=T[x].son[1];
    while(T[z].son[0])
        z=T[z].son[0];
    if(!y && !z)
    {
        rt=0;
        return;
    }
    if(!y)
    {
        Splay(z, 0);
        T[z].son[0]=0;
        PushUp(z);
        return;
    }
    if(!z)
    {
        Splay(y, 0);
        T[y].son[1]=0;
        PushUp(y);
        return;
    }
    Splay(y, 0);
    Splay(z, y);
    T[z].son[0]=0;
    PushUp(z);
    PushUp(y);
}

int GetRank(int key) //獲得值<=key的節點個數
{
    if(!Find(key))
    {
        Insert(key);
        int tmp=T[T[rt].son[0]].size;
        Delete(key);
        return tmp;
    }
    else
        return T[T[rt].son[0]].size+T[rt].num;
}

void Delete(int l, int r) //刪除值在[l, r]中的所有節點 l!=r
{
    if(!Find(l)) Insert(l);
    int p=Prev();
    if(!Find(r)) Insert(r);
    int q=Succ();
    if(!p && !q)
    {
        rt=0;
        return;
    }
    if(!p)
    {
        T[rt].son[0]=0;
        PushUp(rt);
        return;
    }
    if(!q)
    {
        Splay(p, 0);
        T[rt].son[1]=0;
        PushUp(rt);
        return;
    }
    Splay(p, q);
    T[p].son[1]=0;
    PushUp(p);
    PushUp(q);
}

View Code

相關題目：HNOI 2002 POJ3481 POJ2352 POJ1442

NOI2004 郁悶的出納員

II 用於維護序列： （以序列下標為對象維護，相當於對區間操作）（能夠完成線段樹的操作及其不能完成的操作）

 Struct Tree{

int key, sum, size, fa, son[2];

}

支持操作：

void PushUp(int x);

void PushDown(int x);

int MakeTree(int l, int r, int a[]); //新建一個子樹返回根節點

void Rotate(int x, int p); //0左旋 1右旋

void Splay(int x, int To); //將x節點移動到To的子節點中

int Select(int p, int To); //將第p個數移動到To的子節點中 並返回該節點

int Find(int key); //返回值為key的節點 若無返回0 若有將其轉移到根處

int Prev(); //返回根節點的前驅

int Succ(); //返回根結點的后繼

void Insert(int p, int l, int r, int a[]) //將a[l .. r]的數插入到下標為p后面

void Delete(int l, int r); //刪除區間[l, r]中的節點

int Query(int l, int r); //返回[l, r]的和

待補充。。

Size Balance Tree

和上述兩種二叉樹比起來，SBT可能是最像真正平衡二叉樹吧。

SBT能夠保證樹的高度在lgn，這樣對於插入，刪除操作都能夠准確保證時間復雜度在O(lgn)

Maintain操作事實上理解起來也是挺簡單的，至於證明參見CQF神牛的 《SBT》 

模版：

int cnt, rt;

struct Tree
{
    int key, size, son[2];
}T[MAXN];

inline void PushUp(int x)
{
    T[x].size=T[T[x].son[0]].size+T[T[x].son[1]].size+1;
}

inline int Newnode(int key)
{
    ++cnt;
    T[cnt].key=key;
    T[cnt].size=1;
    T[cnt].son[0]=T[cnt].son[1]=0;
    return cnt;
}

void Rotate(int p, int &x)
{
    int y=T[x].son[!p];
    T[x].son[!p]=T[y].son[p];
    T[y].son[p]=x;
    PushUp(x);
    PushUp(y);
    x=y;
}

void Maintain(int &x, int p) //維護SBT的!p子樹
{
    if(T[T[T[x].son[p]].son[p]].size > T[T[x].son[!p]].size)
        Rotate(!p, x);
    else if(T[T[T[x].son[p]].son[!p]].size > T[T[x].son[!p]].size)
        Rotate(p, T[x].son[p]), Rotate(!p, x);
    else return;
    Maintain(T[x].son[0], 0);
    Maintain(T[x].son[1], 1);
    Maintain(x, 0);
    Maintain(x, 1);
}

inline int Prev() //返回比根值小的最大值 若無返回0
{
    int x=T[rt].son[0];
    if(!x) return 0;
    while(T[x].son[1])
        x=T[x].son[1];
    return x;
}

inline int Succ() //返回比根值大的最小值 若無返回0
{
    int x=T[rt].son[1];
    if(!x) return 0;
    while(T[x].son[0])
        x=T[x].son[0];
    return x;
}

void Insert(int key, int &x)
{
    if(!x) x=Newnode(key);
    else
    {
        T[x].size++;
        Insert(key, T[x].son[key > T[x].key]);
        Maintain(x, key > T[x].key);
    }
}

bool Delete(int key, int &x) //刪除值為key的節點 key可以不存在
{
    if(!x) return 0;
    if(T[x].key == key)
    {
        if(!T[x].son[0])
        {
            x=T[x].son[1];
            return 1;
        }
        if(!T[x].son[1])
        {
            x=T[x].son[0];
            return 1;
        }
        int y=Prev();
        T[x].size--;
        return Delete(T[x].key, T[x].son[0]);
    }
    else
        if(Delete(key, T[x].son[key > T[x].key]))
        {
            T[x].size--;
            return 1;
        }
}

int GetPth(int p, int &x) //返回第p小的節點
{
    if(!x) return 0;
    if(p == T[T[x].son[0]].size+1)
        return x;
    if(p > T[T[x].son[0]].size+1)
        return GetPth(p-T[T[x].son[0]].size-1, T[x].son[1]);
    else
        return GetPth(p, T[x].son[0]);
}

int GetRank(int key, int &x) //找出值<=key的節點個數
{
    if(!x) return 0;
    if(T[x].key <= key)
        return T[T[x].son[0]].size+1+GetRank(key, T[x].son[1]);
    else
        return GetRank(key, T[x].son[0]);
}

View Code

相關題目：POJ 3481

上述題均為用於測試平衡樹基本操作的題目。

提高題：

[NOI2005]維修數列

[POJ3580]SuperMemo

[HNOI2004]寵物收養所

在文章的最后貼上一個二叉樹專題訓練https://vjudge.net/contest/84416;jsessionid=E73DCD38F70FF141A029A2DB5958B2F1

喜歡的點個贊並訂閱我們，我們將會提供最優質的文章供大家學習參考，歡迎大家一起學習QAQ