平衡树Treap入门

平衡树，维护的是两个性质，每个节点有两个权值，第一个是它的值val，第二个是你赋予它的一个随机权值rand。

堆：任何结点的父节点的 rand 都大于 （等于）$or$ 小于（等于）它的rand

二叉搜索树：一个结点左孩子（如果有）的 val 大于它的 val ，右孩子（如果有）的 val 大于它的 val。

---

一，旋转操作

旋转操作的核心是，在不破坏除了当前旋转两点的堆性质，所有节点满足二叉搜索树的情况下，将一个结点旋到其父节点的位置上。

本人很懒，借用一下这篇博客的图

这是一个左旋操作：将A的左孩子B在不改变平衡树两个性质的情况下旋转至A的位置。

对于二叉搜索树：

我们现在可以保证，旋转完需要保证的是，左子树的所有val都小于其父节点的val及其右子树，因此图中 C < B < D < A < E 也是很容易理解的。
B的右孩子换成了A，那么D去哪？D 如果在C的孩子的话，D > B，不符合性质，经过推演，发现D应该放在A的左边。
D < A， D > B > C, 符合二叉搜索树的性质。

对于堆：

我们现在最少可以保证的是除了b， 其它的结点的rand都是大于其父节点，否则无法操作。
d.rand > b.rand > a.rand，因此将d放置于a的左孩子时 ，d.rand > a.rand 满足性质。

---

噫，好！我们现在有了一个能在不破坏现有条件下移动的一个操作，代码实现也不是很困难。

void rotate(int &p, int k){
//当k = 0时，此段代码为左旋，也从这个角度来分析，右旋也类似，可以自己手推一下。
// p 为图中的 A，t 为 图中的 B，r 为图中的D
	int t = tree[p].son[k];
	int r = tree[t].son[!k];//D是B的右结点，son[1]，k = 0，因此为!k
    tree[t].son[!k] = p;
    tree[p].son[k] = r;//将D(r)放置在p的左孩子上
    push_up(p);
    //更改完了, A(p)的size更新一下，也就是
    //原本A的值为 B(t).size + E.size
    //现在是D.size+E.size
    push_up(t);//由于t在p的上面了，所以要先push_up(p)
    p = t;//现在父节点变成t了，自然是要变一下。
}

---

二，插入（新建结点 $or$ 修改结点）

插入一个x值，如果相同的val的数会存在同一个结点。
首先，为了满足二叉搜索树的性质，x < tree[p].val那么x 在其左子树内，x > tree[p].val时 x 在其右子树内，x = tree[p].val说明当前结点就是该数，那么出现次数++。
如果递归到了 p = 0，意味着 x 没出现过，那么 新建一个点并赋予一个 rand ，从下往上维护堆的性质，如果不符，那么旋转，直到根。

---

三，查询

与新建一样，先递归查找，若没有返回0，若有返回该数出现次数。

---

剩下的操作包括但不限于：前驱，后继，排名，排名为x的数，都算是好推，就不赘述了。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<stack>
#include<vector>
#include<queue>
#include<cstring>
#include<cmath>
#include<set>
#define int long long
using namespace std;
struct Node{
    int size;
	int son[2];
	int val;
	int w;
	int rnd;
};
Node tree[100005];
int cnt = 0;
void push_up(int p){
    tree[p].size = tree[tree[p].son[0]].size + tree[tree[p].son[1]].size + tree[p].w;
}
int random(int l, int r){
    return rand() * rand() % (r - l + 1) + l;
}
void rotate(int &p, int k){
	int t = tree[p].son[k];
	int r = tree[t].son[!k];
    tree[t].son[!k] = p;
    tree[p].son[k] = r;
    push_up(p);
    push_up(t);
    p = t;
}
void insert(int &p, int x){
	if(p == 0){//传到 0 发现没有， 那么新建 
		cnt++;
	    p = cnt;
	    tree[p].val = x;
	    tree[p].w = 1;
	    tree[p].size = 1;
	    tree[p].rnd = random(1, 1e9);
	    return;
	}
    if(tree[p].val == x){//已经有了 
        tree[p].w++;
        push_up(p);
        return;
	}
	int k = 0;
	if(tree[p].val < x){
	    k = 1;//右边走 
	} else {
	    k = 0;//左边走 
	}
	insert(tree[p].son[k], x);
	if(tree[tree[p].son[k]].rnd < tree[p].rnd){//如果要往上移 
	    rotate(p, k); 
	}
	push_up(p);
}
void del(int &p, int x){
	if(p == 0){
	    return;
	}
//	cout << "v" << tree[p].val << endl;
    if(tree[p].val == x){
        if(tree[p].w > 1){
            tree[p].w--;
            tree[p].size--;
            return;
		}
		int lc = tree[p].son[0];
		int rc = tree[p].son[1];
		if(lc == 0 && rc == 0){
		    p = 0;
		} else if(lc == 0 && rc != 0){
        //    cout << 1 << " " << tree[p].val << "<-" << tree[rc].val << endl;
		    rotate(p, 1);
		    del(tree[p].son[0], x);
		} else if(lc != 0 && rc == 0){
        //    cout << 0 << " " << tree[p].val << "<-" << tree[lc].val << endl;
		    rotate(p, 0);
		    del(tree[p].son[1], x);
		} else {
		    if(tree[lc].rnd < tree[rc].rnd){
             //   cout << 0 << " " << tree[p].val << "<-" << tree[lc].val << endl;
		        rotate(p, 0);
		        del(tree[p].son[1], x);
		    } else {
           //     cout << 1 << " " << tree[p].val << "<-" << tree[rc].val << endl;
		    	rotate(p, 1);
		    	del(tree[p].son[0], x);
		    }
		}
	} else {
		int k = 0;
	    if(tree[p].val > x){
	    	k = 0;
		} else {
		    k = 1;
		}
		del(tree[p].son[k], x);
	}
 //   cout << "p" << tree[p].val << endl;
	push_up(p);
}
int query_rank(int p, int x){
	if(p == 0) return 0;
    if(tree[p].val > x){
        return query_rank(tree[p].son[0], x);
	}
	if(tree[p].val < x){
        return tree[tree[p].son[0]].size + tree[p].w + query_rank(tree[p].son[1], x);
	}
	return tree[tree[p].son[0]].size;
}
int query_pre(int p, int k){//前驱 
    if(p == 0){
        return -1e9;
	}
    if(tree[p].val < k){
        return max(tree[p].val, query_pre(tree[p].son[1], k));
	}
	return query_pre(tree[p].son[0], k);
}
int query_nxt(int p, int k){//后驱 
    if(p == 0){
        return 1e9;
	}
    if(tree[p].val > k){
        return min(tree[p].val, query_nxt(tree[p].son[0], k));
	}
	return query_nxt(tree[p].son[1], k);
}
int query_rankx(int p, int x){//
	int lc = tree[p].son[0];
	int rc = tree[p].son[1];
    if(tree[lc].size >= x){
        return query_rankx(lc, x);
	} else if(tree[lc].size < x - tree[p].w){
	    return query_rankx(rc, x - tree[lc].size - tree[p].w);
	} else {
	    return tree[p].val;
	}
}
signed main(){
    int n;
    cin >> n;
    int r = 0;
    for(int i = 0; i < n; i++){
    	int op, t;
        cin >> op >> t;
  //  cout << i << " " << op << " ___" << endl;
	    if(op == 1){//插入 
	        insert(r, t);
	    //    validate(r);
		} else if(op == 2){//删除
		    del(r, t);
	//	    validate(r);
		} else if(op == 3){//x数的排名
		    cout << query_rank(r, t) + 1 << endl;
		} else if(op == 4){//第x个数
			cout << query_rankx(r, t) << endl;
		} else if(op == 5){
		    cout << query_pre(r, t) << endl;
		} else if(op == 6){
		    cout << query_nxt(r, t) << endl;
		}
      //  print();
	}
    return 0;
}