非旋Treap講解

Treap，一種平衡樹。作為一棵平衡樹，一定是遵從著某種原則，使得這棵樹儘量的接近完全二叉樹。除了二叉搜尋樹都具備的性質——左子樹 ≤ 根 ≤ 右子樹，顧名思義，Treap = tree＋heap。這時他的特殊性質就飄出水面了——heap。有一個需要慢慢理解的東西，我覺得是本文最重要的——二叉搜尋樹中順次排列所參考的引數是靈活的，誰說非要按數值？？有的題你就得用下標。

一、每個node的元素組成

對於一個node，有fix（隨機分配的數，用rand即可），size（這個node所引領的樹的大小，包括自己），剩下的引數視情況而定。這棵樹所包含點的fix值，需要滿足堆的性質，一般情況下我們會使用最小堆（約定俗成）。以bzoj3224為例：

struct Treap {
    Treap *l, *r;
    int fix, key, size; //fix表示隨機值，key表示數值，size表示以它為根的這棵子樹的大小
    Treap(int key_):fix(randad()), key(key_), l(NULL), r(NULL), size(1) {}
    inline void updata() {
        //更新樹的大小
        size = 1 + (l?l->size:0) + (r?r->size:0);
    }
}*root;
typedef pair<Treap*, Treap*> Droot;
inline int Size(Treap *x) {return x?x->size:0;}

一定要注意！在改了某節點後，一定要update！

二、基礎的操作

有人會說，既然都不旋轉了，那肯定操作起來特別難。好吧我告訴你們，真的挺難。不過只要認真看完我的文章（老臉一紅）並多多練習，我相信你一定能使用的得心應手。

①Split

先下個定義：Split(x, k)表示，把x引導的這一棵樹的前k個節點（順序是按照左子樹 ≤ 根 ≤ 右子樹來劃定的）從樹中分離出來。函式的返回結果是一個節點對，記作（x1, x2），此時x1所引導的樹就是前k個節點，x2引導的樹就是剩下的節點。注意：Split之後，我們已經真真切切的把它們切開了，現在我們的Treap已經不是一個整體了，一定要養成好習慣，Split之後不要忘了再合併起來（合併是我們要講的下一個基礎操作）。那具體怎麼做呢？

Droot Split(Treap *x, int k) {
    if(!x) return Droot(NULL, NULL);
    Droot y;
    if(Size(x->l) >= k) { //如果左子樹的節點數能達到k個，則前k個一定都在左子樹中
        y = Split(x->l, k);
        x->l = y.second; //x的左子樹只留下來了不在前k個位置的節點
        x->updata();
        y.second = x; //此時x這棵樹可以整個拖上去，作為以前不在前k個位置的節點集合
    }else {
        y = Split(x->r, k - Size(x->l) - 1); //要在右子樹搜尋前幾個，連同根節點與左子樹，作為前k個
        x->r = y.first; //x的右子樹變為以前的右子樹的前幾個（此時x的size應恰為k）
        x->updata();
        y.first = x; //整個拖上去，作為前k個位置的點的集合
    }
    return y;
}
 

②Merge

繼續下定義：Merge（x，y）表示，把x這棵樹與y這棵樹合併起來（必須滿足的條件：在劃分順序時，x中所有元素都應排在y中的元素的前面。所以我認為Merge最重要的性質在於有序性）。函式的返回結果是一個節點，表示合併後這棵樹的樹根。

Treap *Merge(Treap *A, Treap *B) {
    if(!A) return B;
    if(!B) return A;
    if(A->fix < B->fix) { //如果A的隨機數比較小，那他應該居上
        A->r = Merge(A->r, B); //而B本就應該排A後面，於是把A的右子樹和B合併，一併作為A的右子樹（注意順序）
        A->updata();
        return A;
    }else { //B居上
        B->l = Merge(A, B->l); //把A和B的左子樹合併，一併作為B的左子樹
        B->updata();
        return B;
    }
}

於是，到現在，基本的操作你就都會了。我們來應用一下。看一下bzoj3224，要我們支援的操作有6個，我們一一來分析。①先說查詢一個數的排名。就和普通二叉搜尋樹沒什麼區別的，直接上程式碼。

inline int Getkth(Treap *x, int v) {
    //詢問一個數是第幾小 
    if(!x) return 0;
    int ans = 0, temp = (int)2e9+1;
    while(x) {
        if(v == x->key) temp = min(temp, ans + Size(x->l) + 1);
        if(v > x->key) ans+= Size(x->l) + 1, x = x->r;
        else x = x->l;
    }
    return temp==(int)2e9+1?ans:temp;
}

②順便一塊把查詢第幾名是誰說了吧。異曲同工。

int Findkth(int k) {
    //尋找第k小
    Treap *p; p = root;
    while(true) {
        if(Size(p->l) == k - 1) return p->key;
        if(Size(p->l) > k - 1) p = p->l;
        else k-= (Size(p->l) + 1), p = p->r;
    }
}

③Insert：只加入一個數，於是我們先查詢，在平衡樹中有幾個比x小的（用Getkth，這就是為什麼我先講查排名），記為k，然後把樹分開，把節點放中間，合併。

inline void Insert(int v) {
    int k = Getkth(root, v);
    Droot x = Split(root, k);
    Treap *n = new Treap(v);
    root = Merge(Merge(x.first, n), x.second);
    return ;
}

④Delete：刪除。與insert一樣，分成三段——前k-1個，第k個，後面剩下的。直接合並第1、3段即可。（如果必要，最好隨刪隨清記憶體，這就是指標的好處。但指標的壞處就是極其不可控，容易re）刪記憶體程式碼：

void del(Treap *p) {
	if(!p) return ;
	if(p->l) del(p->l);
	if(p->r) del(p->r);
	delete p;
}

⑤⑥前驅與後繼，這個很簡單，就是利用查排名函式。

inline int pre(Treap *k, int x) {
    int ans = (int)-2e9-1;
    while(k) {
        if(k->key < x) ans = max(ans, k->key), k = k->r;
        else k = k->l;
    }
    return ans;
}

inline neg(Treap *k, int x) {
    int ans = (int)2e9+1;
    while(k) {
        if(k->key > x) ans = min(ans, k->key), k = k->l;
        else k = k->r;
    }
    return ans;
}

再看一個應用，笛卡爾樹。我們知道，加點的複雜度是log級的，批量加點複雜度顯然有一點大（其實我只是想去掉一點常數，log級並沒有那麼大，但是oj也許會卡）。批量加數時，先存進陣列a中，a[0]表示一共有多少數要進樹。

Treap *Build(int *a) {
	static Treap *x, *last;
	int p = 0;
	for(int i = 1; i <= a[0]; ++i) {
		x = new Treap(a[i]);
		last = NULL;
		while(p && sta[p]->fix > x->fix) {
			sta[p]->updata();
			last = sta[p];
			sta[p--] = NULL;
		}
		if(p) sta[p]->r = x;
		x->l = last;
		sta[++p] = x;
	}
	while(p) sta[p--]->updata();
	return sta[1];
}

至此，Treap的基本知識已經講完了。如果大家有興趣看一下平衡樹的操作boss題，我推薦bzoj1500維修數列。附上我的維修數列Treap版程式碼：http://paste.ubuntu.com/26194333/