平衡樹算法

一、平衡樹用來干什么

您需要寫一種數據結構（可參考題目標題），來維護一些數，其中需要提供以下操作：

1. 插入 xxx 數
2. 刪除 xxx 數(若有多個相同的數，因只刪除一個)
3. 查詢 xxx 數的排名(排名定義為比當前數小的數的個數 +1+1+1 )
4. 查詢排名為 xxx 的數
5. 求 xxx 的前驅(前驅定義為小於 xxx，且最大的數)
6. 求 xxx 的后繼(后繼定義為大於 xxx，且最小的數)

 

 

 

二、平衡樹與二叉排序樹區別

平衡樹是二叉搜索樹和堆合並構成的數據結構，它是一 棵空樹或它的左右兩個子樹的高度差的絕對值不超過1，並且左右兩個子樹都是一棵平衡二叉樹。平衡樹的平均查找長度要小於等於二叉排序樹的平均查找長度

平衡樹是二叉排序樹通過旋轉來達到最優二叉排序樹

平衡樹本身就是二叉排序樹

 

不懂二叉排序樹的可以看一下：二叉排序樹的構造 && 二叉樹的先序、中序、后序遍歷

 

三、二叉平衡樹復雜度

前提：包含n個頂點的二叉平衡樹（AVL樹）

1、查找一個節點時間復雜度為O(lgn)

2、插入的時間復雜度O(lgn)

3、刪除一個節點時間復雜度為O(lgn)

 

 

代碼中會發現每一次操作之后都會進行旋轉操作，這樣導致平衡樹的時間復雜度常數很大

 

四、平衡樹的構造

參考鏈接：https://blog.csdn.net/a_comme_amour/article/details/79382104

 

1、變量聲明

 

f[i]表示i的父結點，ch[i][0]表示i的左兒子，ch[i][1]表示i的右兒子，key[i]表示i的關鍵字（即結點i代表的那個數字），cnt[i]表示i結點的關鍵字出現的次數（相當於權值），sizes[i]表示包括i的這個子樹的大小；sz為整棵樹的大小，rt為整棵樹的根。

注意：

sz代表的是不同節點種類數，比如你要插入5 5 4 3 4這些數，那么sz的大小是3

sizes代表的就是節點有幾個，就不是種類個數了

 

幾個小函數：

void clears(int x) //刪除x點信息
{
    f[x]=cnt[x]=ch[x][0]=ch[x][1]=sizes[x]=key[x]=0;
}
bool get(int x) //判斷x是父節點的左孩子還是右孩子
{
    return ch[f[x]][1]==x;  //返回1就是右孩子，返回0就是左孩子
}
void pushup(int x)  //重新計算一下x這棵子樹的節點數量
{
    if(x)
    {
        sizes[x]=cnt[x];
        if(ch[x][0]) sizes[x]+=sizes[ch[x][0]];
        if(ch[x][1]) sizes[x]+=sizes[ch[x][1]];
    }
}

 

 

2、旋轉操作

 

 怎么旋轉看下面

 

 讓4旋轉到他的父親位置2（我們代碼中的旋轉就是讓一個節點移動到他的父親節點位置）

首先我們要知道平衡樹就是二叉排序樹，那么二叉排序樹兒子節點的特點就是左節點的值小於父節點的值，右節點的值大於父節點的值

那么4節點移動到了2節點（4節點的父親節點）的位置，4節點會把它的右兒子（也就是9號節點）給2號節點充當左兒子，然后2號節點在作為4號節點的右兒子節點出現

 

 旋轉操作代碼：

void rotates(int x)  //將x移動到他父親的位置，並且保證樹依舊平衡
{
    int fx=f[x],ffx=f[fx],which=get(x);
    //x點父親，要接受x的兒子。而且x與x父親身份交換
    ch[fx][which]=ch[x][which^1];
    f[ch[fx][which]]=fx;

    ch[x][which^1]=fx;
    f[fx]=x;

    f[x]=ffx;
    if(ffx) ch[ffx][ch[ffx][1]==fx]=x;

    pushup(fx);
    pushup(x);
}

 

3、splay操作

 

這個就是把樹上的一個節點旋轉的樹根位置，分為兩種操作：

<一>、

一個點p和他的父親（fa）同為一邊的兒子（如圖同為左兒子） 此時應先rotate(p.fa), 再rotate(p)

 

 

 

<二>、

一個點p和他的父親不是同一邊的兒子 此時兩次rotate(p)即可

void splay(int x)  //將x移動到數根節點的位置，並且保證樹依舊平衡
{
    for(int fx; fx=f[x]; rotates(x))
    {
        if(f[fx])
        {
            rotates((get(x)==get(fx))?fx:x);
            //如果祖父三代連城一條線，就要從祖父哪里rotate
            //至於為什么要這樣做才能最快……可以去看看Dr.Tarjan的論文
        }
    }
    rt=x;
}

注意：void splay(int x)  這個x是這個節點在樹上的位置

 

假設上面節點1、fa、3的cnt值都為1 

那么這個fa這個節點在樹上的位置就是2，3這個節點在樹上的位置就是3

 

4、void inserts(int x)，插入一個節點（這個x是你要插入值的大小）

 

代碼實現

void inserts(int x)
{
    if(rt==0)
    {
        sz++;
        key[sz]=x;
        rt=sz;
        cnt[sz]=sizes[sz]=1;
        f[sz]=ch[sz][0]=ch[sz][1]=0;
        return;
    }
    int now=rt,fx=0;
    while(1)
    {
        if(x==key[now])
        {
            cnt[now]++;
            pushup(now);
            pushup(fx);
            splay(now);  //splay的過程會rotates now點的所有祖先節點，這個時候它們所有子樹權值也更新了
            return;
        }
        fx=now;
        now=ch[now][key[now]<x];
        if(now==0)
        {
            sz++;
            sizes[sz]=cnt[sz]=1;
            ch[sz][0]=ch[sz][1]=0;
            ch[fx][x>key[fx]]=sz;  //二叉查找樹特性”左大右小“
            f[sz]=fx;
            key[sz]=x;
            pushup(fx);
            splay(sz);
            return ;
        }
    }
}

注意：插入完之后要把這個剛插入到樹上的點給通過splay函數旋轉到樹根，至於為什么要這樣做。大家可以這樣想，假設插入之前的樹是一顆最優二叉排序樹，那么插入一個點之后可能就不最優了，所以我們要旋轉這棵樹，以保證這棵樹還是最優的

 

5、int rnk(int x)  //查詢x的排名

 

這個函數就是插入x這個值，他在平衡樹上的位置

代碼實現

/*
有人問：
很想知道為什么rnk操作也要splay操作呢？如果del要用的話直接splay（x）是不是就可以了

原博客答：
呃不不不這個貌似不是隨便splay以下就可以的 首先find之后的splay就是將找到的這個點轉到根，
當然你不加這個應該是也可以，只不過這道題加上的話對於這一堆操作來說比較方便，不過一般來說轉一轉splay的
平衡性會好一點（當然也不要轉得太多了就tle了...） 但是del之前直接splay(x)要視情況而定，關鍵在於分清楚
“點的編號”和“點的權值”這兩個概念。如果你已經知道了該轉的點的編號，當然可以直接splay(x)，但是如果你只
知道應該splay的點的權值，你需要在樹里find到這個權值的點的編號，然后再splay 其實最后splay寫起來都是非
常靈活的，而且有可能一個點帶若干個權之類的。對於初學者的建議就是先把一些最簡單的情況搞清楚，比如說一
個編號一個權的這種，然后慢慢地多做題就能運用得非常熟練了。最好的方法就是多畫畫樹自己轉一轉，對之后
復雜題目的調試也非常有益

我說：
我在洛谷上得模板題上交了一下rnk里面不帶splay(now)的，一共12個樣例，就對了兩個樣例。錯了一個樣例，其他全TLE

我解釋：
為什么作者解釋可以刪去，但是刪過之后還錯了。因為它的代碼中函數之前是相互聯系的
就比如它調用rnk(x)函數之后就已經認為x為平衡樹樹根，然后直接對它進行下一步操作(這個假設在del函數里面)

如果你光刪了rnk(x)里面的splay()，你肯定還要改其他地方代碼。。。。。。
*/
int rnk(int x)  //查詢x的排名
{
    int now=rt,ans=0;
    while(1)
    {
        if(x<key[now]) now=ch[now][0];
        else
        {
            ans+=sizes[ch[now][0]];
            if(x==key[now])
            {
                splay(now); //這個splay是為了后面函數的調用提供前提條件
//就比如pre函數的前提條件就是x（x是我們要求誰的前驅，那個誰就是x）已經在平衡樹樹根
                return ans+1;
            }
            ans+=cnt[now];  //cnt代表now這個位置值（key[now]）出現了幾次
            now=ch[now][1];
        }
    }
}

 

 

6、int kth(int x)

 

這個是查找樹上面第x大的數是多少

int kth(int x)
{
    int now=rt;
    while(1)
    {
        if(ch[now][0] && x<=sizes[ch[now][0]])
        {
            //滿足這個條件就說明它在左子樹上
            now=ch[now][0];
        }
        else
        {
            int temp=sizes[ch[now][0]]+cnt[now];
            if(x<=temp) //這個temp是now左子樹權值和now節點權值之和
                return key[now]; //進到這個判斷里面說明他不在左子樹又不在右子樹，那就是now節點了
            x-=temp;
            now=ch[now][1];
        }
    }
}

 

7、求根節點的前驅節點和后繼結點在樹上的位置

int pre()//由於進行splay后，x已經到了根節點的位置
{
    //求x的前驅其實就是求x的左子樹的最右邊的一個結點
//為什么呢，因為這是平衡樹（帶有二叉排序樹特點），根據二叉排序樹中序遍歷結果我么可以知道，一個數的前序就在
//x的左子樹的最右邊的一個結點
    int now=ch[rt][0];
    while(ch[now][1]) now=ch[now][1];
    return now;
}
int next()
{
    //求后繼是求x的右子樹的最左邊一個結點
//為什么呢，因為這是平衡樹（帶有二叉排序樹特點），根據二叉排序樹中序遍歷結果我么可以知道，一個數的前序就在
//x的右子樹的最左邊一個結點
    int now=ch[rt][1];
    while(ch[now][0])  now=ch[now][0];
    return now;
}

 

8、刪除一個值

/*
刪除操作是最后一個稍微有點麻煩的操作。
step 1：隨便find一下x。目的是：將x旋轉到根。
step 2：那么現在x就是根了。如果cnt[root]>1，即不只有一個x的話，直接-1返回。
step 3：如果root並沒有孩子，就說名樹上只有一個x而已，直接clear返回。
step 4：如果root只有左兒子或者右兒子，那么直接clear root，然后把唯一的兒子當作根就可以了（f賦0，root賦為唯一的兒子）
剩下的就是它有兩個兒子的情況。
step 5：我們找到新根，也就是x的前驅（x左子樹最大的一個點），將它旋轉到根。然后將原來x的右子樹接到新根的
右子樹上（注意這個操作需要改變父子關系）。這實際上就把x刪除了。不要忘了update新根。
*/
void del(int x)
{
    rnk(x);
    if(cnt[rt]>1)//如果這個位置權值大於1，那就不用刪除這個點
    {
        cnt[rt]--;
        pushup(rt);
        return;
    }
    if(!ch[rt][0] && !ch[rt][1]) //這個就代表平衡樹只有一個節點
    {
        clears(rt);
        rt=0;
        return;
    }
    if(!ch[rt][0]) //只有左兒子，樹根只有左兒子那就把樹根直接刪了就行
    { //然后左兒子這棵子樹變成新的平衡樹
        int frt=rt;
        rt=ch[rt][1];
        f[rt]=0;
        clears(frt);
        return;
    }
    else if(!ch[rt][1]) //只有右兒子，和上面差不多
    {
        int frt=rt;
        rt=ch[rt][0];
        f[rt]=0;
        clears(frt);
        return;
    }
    int frt=rt;
    int leftbig=pre();
    splay(leftbig); //讓前驅做新根
    ch[rt][1]=ch[frt][1];  //這個frt指向的還是之前的根節點
    /*
    看着一點的時候就會發現，數在數組里面的位置一直沒有改變，平衡樹旋轉改變的是根節點兒子數組ch[x][]指向的值
    */
    f[ch[frt][1]]=rt;
    clears(frt);
    pushup(rt);
}

 

五、例題

P3369 【模板】普通平衡樹

 

題目描述

您需要寫一種數據結構（可參考題目標題），來維護一些數，其中需要提供以下操作：

1. 插入 xxx 數
2. 刪除 xxx 數(若有多個相同的數，因只刪除一個)
3. 查詢 xxx 數的排名(排名定義為比當前數小的數的個數 +1+1+1 )
4. 查詢排名為 xxx 的數
5. 求 xxx 的前驅(前驅定義為小於 xxx，且最大的數)
6. 求 xxx 的后繼(后繼定義為大於 xxx，且最小的數)

輸入格式

第一行為 nnn，表示操作的個數,下面 nnn 行每行有兩個數 opt\text{opt}opt 和 xxx，opt\text{opt}opt 表示操作的序號( 1≤opt≤6 1 \leq \text{opt} \leq 6 1≤opt≤6 )

輸出格式

對於操作 3,4,5,63,4,5,63,4,5,6 每行輸出一個數，表示對應答案

輸入輸出樣例

輸入 #1 復制

10
1 106465
4 1
1 317721
1 460929
1 644985
1 84185
1 89851
6 81968
1 492737
5 493598

輸出 #1 復制

106465
84185
492737

說明/提示

【數據范圍】
對於 100%100\%100% 的數據，1≤n≤1051\le n \le 10^51≤n≤105，∣x∣≤107|x| \le 10^7∣x∣≤107

 

代碼：

/*
注意：
1、看平衡樹之前你要注意，對於1 3 5 3 2這一組數據。sz的值是4，因為sz保存的是節點種類
   為什么要這樣，因為sz涉及到要為幾個點開空間

2、sizes[x]保存的是以x為樹根的子樹上節點數量，比如x這顆子樹所有節點為1，2，1.那么它的sizes[x]=3
   而且實際上不會有兩個1放在樹上。而是給1的權值數組cnt[1]加1

3、對於1 3 5 3 2這一組數據。sz的值是4。那么1對應位置就是1，3對應位置就是2，5對應位置就是3，2對應位置就是4
   之后他們所對應的位置都不會改變
   在平衡樹旋轉的過程中只是每一個點的兒子節點ch[x][0]和ch[x][1]里面保存的值在改變
*/
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
const int maxn=1e5+10;
int f[maxn],cnt[maxn],ch[maxn][2],sizes[maxn],key[maxn],sz,rt;
/*
f[i]:i節點的父節點,cnt[i]每個點出現的次數,ch[i][0/1]:0表示左孩子，
1表示右孩子, size[i]表示以i為根節點的子樹的節點個數
key[i]表示點i代表的數的值；sz為整棵樹的節點種類數，rt表示根節點
*/
void clears(int x) //刪除x點信息
{
    f[x]=cnt[x]=ch[x][0]=ch[x][1]=sizes[x]=key[x]=0;
}
bool get(int x) //判斷x是父節點的左孩子還是右孩子
{
    return ch[f[x]][1]==x;  //返回1就是右孩子，返回0就是左孩子
}
void pushup(int x)  //重新計算一下x這棵子樹的節點數量
{
    if(x)
    {
        sizes[x]=cnt[x];
        if(ch[x][0]) sizes[x]+=sizes[ch[x][0]];
        if(ch[x][1]) sizes[x]+=sizes[ch[x][1]];
    }
}
void rotates(int x)  //將x移動到他父親的位置，並且保證樹依舊平衡
{
    int fx=f[x],ffx=f[fx],which=get(x);
    //x點父親，要接受x的兒子。而且x與x父親身份交換
    ch[fx][which]=ch[x][which^1];
    f[ch[fx][which]]=fx;

    ch[x][which^1]=fx;
    f[fx]=x;

    f[x]=ffx;
    if(ffx) ch[ffx][ch[ffx][1]==fx]=x;

    pushup(fx);
    pushup(x);
}
void splay(int x)  //將x移動到數根節點的位置，並且保證樹依舊平衡
{
    for(int fx; fx=f[x]; rotates(x))
    {
        if(f[fx])
        {
            rotates((get(x)==get(fx))?fx:x);
            //如果祖父三代連城一條線，就要從祖父哪里rotate
            //至於為什么要這樣做才能最快……可以去看看Dr.Tarjan的論文
        }
    }
    rt=x;
}
/*
將x這個值插入到平衡樹上面
如果這個值在樹上存在過，那就sz不再加1，更新一下權值即可
如果這個值在樹上不存在，那就sz加1，再更新一下權值

sz是書上節點種類數
sizes[x]是x這棵子樹上有多少節點
*/
void inserts(int x)
{
    if(rt==0)
    {
        sz++;
        key[sz]=x;
        rt=sz;
        cnt[sz]=sizes[sz]=1;
        f[sz]=ch[sz][0]=ch[sz][1]=0;
        return;
    }
    int now=rt,fx=0;
    while(1)
    {
        if(x==key[now])
        {
            cnt[now]++;
            pushup(now);
            pushup(fx);
            splay(now);  //splay的過程會rotates now點的所有祖先節點，這個時候它們所有子樹權值也更新了
            return;
        }
        fx=now;
        now=ch[now][key[now]<x];
        if(now==0)
        {
            sz++;
            sizes[sz]=cnt[sz]=1;
            ch[sz][0]=ch[sz][1]=0;
            ch[fx][x>key[fx]]=sz;  //二叉查找樹特性”左大右小“
            f[sz]=fx;
            key[sz]=x;
            pushup(fx);
            splay(sz);
            return ;
        }
    }
}
/*
有人問：
qwq很想知道為什么find操作也要splay操作呢？如果del要用的話直接splay（x）是不是就可以了

原博客答：
呃不不不這個貌似不是隨便splay以下就可以的 首先find之后的splay就是將找到的這個點轉到根，
當然你不加這個應該是也可以，只不過這道題加上的話對於這一堆操作來說比較方便，不過一般來說轉一轉splay的
平衡性會好一點（當然也不要轉得太多了就tle了...） 但是del之前直接splay(x)要視情況而定，關鍵在於分清楚
“點的編號”和“點的權值”這兩個概念。如果你已經知道了該轉的點的編號，當然可以直接splay(x)，但是如果你只
知道應該splay的點的權值，你需要在樹里find到這個權值的點的編號，然后再splay 其實最后splay寫起來都是非
常靈活的，而且有可能一個點帶若干個權之類的。對於初學者的建議就是先把一些最簡單的情況搞清楚，比如說一
個編號一個權的這種，然后慢慢地多做題就能運用得非常熟練了。最好的方法就是多畫畫樹自己轉一轉，對之后
復雜題目的調試也非常有益

我說：
我在洛谷上得模板題上交了一下rnk里面不帶splay(now)的，一共12個樣例，就對了兩個樣例。錯了一個樣例，其他全TLE

我解釋：
為什么作者解釋可以刪去，但是刪過之后還錯了。因為它的代碼中函數之前是相互聯系的
就比如它調用rnk(x)函數之后就已經認為x為平衡樹樹根，然后直接對它進行下一步操作(這個假設在del函數里面)

如果你光刪了rnk(x)里面的splay()，你肯定還要改其他地方代碼。。。。。。
*/
int rnk(int x)  //查詢x的排名
{
    int now=rt,ans=0;
    while(1)
    {
        if(x<key[now]) now=ch[now][0];
        else
        {
            ans+=sizes[ch[now][0]];
            if(x==key[now])
            {
                splay(now); //這個splay是為了后面函數的調用提供前提條件
//就比如pre函數的前提條件就是x（x是我們要求誰的前驅，那個誰就是x）已經在平衡樹樹根
                return ans+1;
            }
            ans+=cnt[now];  //cnt代表now這個位置值（key[now]）出現了幾次
            now=ch[now][1];
        }
    }
}
int kth(int x)
{
    int now=rt;
    while(1)
    {
        if(ch[now][0] && x<=sizes[ch[now][0]])
        {
            //滿足這個條件就說明它在左子樹上
            now=ch[now][0];
        }
        else
        {
            int temp=sizes[ch[now][0]]+cnt[now];
            if(x<=temp) //這個temp是now左子樹權值和now節點權值之和
                return key[now]; //進到這個判斷里面說明他不在左子樹又不在右子樹，那就是now節點了
            x-=temp;
            now=ch[now][1];
        }
    }
}
int pre()//由於進行splay后，x已經到了根節點的位置
{
    //求x的前驅其實就是求x的左子樹的最右邊的一個結點
//為什么呢，因為這是平衡樹（帶有二叉排序樹特點），根據二叉排序樹中序遍歷結果我么可以知道，一個數的前序就在
//x的左子樹的最右邊的一個結點
    int now=ch[rt][0];
    while(ch[now][1]) now=ch[now][1];
    return now;
}
int next()
{
    //求后繼是求x的右子樹的最左邊一個結點
//為什么呢，因為這是平衡樹（帶有二叉排序樹特點），根據二叉排序樹中序遍歷結果我么可以知道，一個數的前序就在
//x的右子樹的最左邊一個結點
    int now=ch[rt][1];
    while(ch[now][0])  now=ch[now][0];
    return now;
}
/*
刪除操作是最后一個稍微有點麻煩的操作。
step 1：隨便find一下x。目的是：將x旋轉到根。
step 2：那么現在x就是根了。如果cnt[root]>1，即不只有一個x的話，直接-1返回。
step 3：如果root並沒有孩子，就說名樹上只有一個x而已，直接clear返回。
step 4：如果root只有左兒子或者右兒子，那么直接clear root，然后把唯一的兒子當作根就可以了（f賦0，root賦為唯一的兒子）
剩下的就是它有兩個兒子的情況。
step 5：我們找到新根，也就是x的前驅（x左子樹最大的一個點），將它旋轉到根。然后將原來x的右子樹接到新根的
右子樹上（注意這個操作需要改變父子關系）。這實際上就把x刪除了。不要忘了update新根。
*/
void del(int x)
{
    rnk(x);
    if(cnt[rt]>1)//如果這個位置權值大於1，那就不用刪除這個點
    {
        cnt[rt]--;
        pushup(rt);
        return;
    }
    if(!ch[rt][0] && !ch[rt][1]) //這個就代表平衡樹只有一個節點
    {
        clears(rt);
        rt=0;
        return;
    }
    if(!ch[rt][0]) //只有左兒子，樹根只有左兒子那就把樹根直接刪了就行
    { //然后左兒子這棵子樹變成新的平衡樹
        int frt=rt;
        rt=ch[rt][1];
        f[rt]=0;
        clears(frt);
        return;
    }
    else if(!ch[rt][1]) //只有右兒子，和上面差不多
    {
        int frt=rt;
        rt=ch[rt][0];
        f[rt]=0;
        clears(frt);
        return;
    }
    int frt=rt;
    int leftbig=pre();
    splay(leftbig); //讓前驅做新根
    ch[rt][1]=ch[frt][1];  //這個frt指向的還是之前的根節點
    /*
    看着一點的時候就會發現，數在數組里面的位置一直沒有改變，平衡樹旋轉改變的是根節點兒子數組ch[x][]指向的值
    */
    f[ch[frt][1]]=rt;
    clears(frt);
    pushup(rt);
}
int main()
{
    int n;
    scanf("%d",&n);
    for (int i=1; i<=n; i++)
    {
        int type,k;
        scanf("%d%d",&type,&k);
        if (type==1) inserts(k);
        if (type==2) del(k);
        if (type==3) printf("%d\n",rnk(k));
        if (type==4) printf("%d\n",kth(k));
        if (type==5)
        {
            inserts(k);
            //插入操作中存在splay操作，這樣的話插入之后平衡樹樹根就是k
            printf("%d\n",key[pre()]);
            del(k);
        }
        if (type==6)
        {
            inserts(k);
            printf("%d\n",key[next()]);
            del(k);
        }
    }
    printf("%d %d %d %d\n",sz,sizes[1],sizes[2],sizes[3]);
    return 0;
}