平衡树(Treap模板)

这是一道模板题。

您需要写一种数据结构（普通平衡树），来维护一些数，其中需要提供以下操作：

1.插入 x 数；

2.删除 x 数（若有多个相同的数，只删除一个）；

3.查询 x 数的排名（若有多个相同的数，输出最小的排名）；

4.查询排名为 x 的数；

5.求 x 的前驱（前驱定义为小于 x，且最大的数）；

6.求 x 的后继（后继定义为大于 x，且最小的数）。输入格式

输入格式

第一行为 n，表示操作的个数，下面 n 行每行有两个数 opt 和 x，opt 表示操作的序号（1≤opt≤6）。

输出格式

对于操作 3、4、5、6 每行输出一个数，表示对应答案。

Input

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

 Output

106465
84185
492737

直接创建一个二叉搜索树BST(Binary Search Tree)的话，容易出现像1 2 3 4 5这样插入变成一条链表的情况，时间复杂度变成了O(n)而不再是O(logn)，为了维护一个较好的树形结构(即让BST平衡)，在创建二叉搜索树时还要维护一个大根堆的结构(大根堆就是根节点是整棵树的最大值(根节点大于等于左右子树的最大值))，这样Tree+heap(堆)->Treap。

Treap的模板代码: 

#include <iostream>
using namespace std;
const int N = 1e5+10, INF = 1e9+7;
int n;
struct Node {
    int l, r;  // 左右儿子
    int key;   // 二叉搜索树权值
    int val;   // 大根堆的随机权值
    int cnt;   // 当前节点的key的重复个数
    int size;  // 当前节点的子孙节点个数
} tr[N]; //空间O(N)
 
//Treap在以关键码构成二叉搜索树的同时，还满足堆的性质,且堆的权重随机,这使得treap的期望复杂度是logn
 
int root, idx;// 根节点序号 和 序号
 
//更新父节点size信息,用儿子节点
void pushup(int p) {
    tr[p].size = tr[tr[p].l].size + tr[tr[p].r].size + tr[p].cnt;
}
 
//创建一个叶节点
int get_node(int key){
    tr[++ idx].key = key;
    tr[idx].val = rand();//rand()会返回一个范围在0到RAND_MAX（至少是32767）之间的伪随机数（整数）
    tr[idx].cnt = tr[idx].size = 1;
    return idx;
}
 
//初始化平衡树 左右哨兵 
//y总:如果查询的结果可能不存在，那加上哨兵之后可以保证查询的结果一定存在，就不需要在查询过程中特判无解的情况了。
void build(){
    get_node(-INF),get_node(INF);
    root = 1,tr[1].r = 2;//+inf > -inf,+inf在-inf右边 将1 2连接 
    pushup(root);//更新root的size
}
 
//右旋
void zig(int &p){ //根变了,传引用
// 旋转的时候传root,root会变化,我们希望root还是真正的root,故用root 
// p始终指向根
 	int q = tr[p].l; //q是左儿子
    tr[p].l = tr[q].r,//p的左儿子是q的右儿子
    tr[q].r = p,//q的右儿子是p
    p = q;//p再变回根
    pushup(tr[p].r);//更新p.r
    //旋转(zig zag)里的pushup(p)可以不写，因为在insert和remove函数中最后一定会更新p的
	pushup(p);//更新p 
}
 
//左旋
void zag(int &p){
    int q = tr[p].r;
    tr[p].r = tr[q].l;//p的右儿子是q的左儿子
    tr[q].l = p;//q的左儿子是p
    p = q;//p再变回根
    pushup(tr[p].l);
    pushup(p);    
 
}
 
//插入值key,从根开始
 
void insert(int &p,int key)//p是每一层根节点的指针
{
    if(!p) p = get_node(key);// 不存在根,则构造(最底层时构造节点)
 	else if (tr[p].key == key)tr[p].cnt ++; // 刚好key和p的key相等, 则直接增加cnt
    else if (tr[p].key > key){ // 当前节点值大于key,说明应该在左子树插入
        insert(tr[p].l,key);
        //由于在左子树插入,插入左侧后左子树val可能大于根节点,为保证堆的性质
        //左大右旋
        if(tr[tr[p].l].val > tr[p].val) zig(p);
    }
    else{
        insert(tr[p].r,key);
        //右大左旋
        if(tr[tr[p].r].val > tr[p].val) zag(p);
    }
    pushup(p);//p是每一层的根,指针,自底向上更新p   
}
 
void remove(int &p,int key){
    if(!p) return ;//不存在要删除的值
    if(tr[p].key == key){ //要删除当前节点
        if(tr[p].cnt > 1)tr[p].cnt --;
        else if (tr[p].l || tr[p].r){ // 当前节点只有一个可以且有左儿子或右儿子
            if(!tr[p].r||tr[tr[p].l].val > tr[tr[p].r].val){
            //只存在左儿子或左val>右val 
                zig(p);//左大右旋
                remove(tr[p].r,key);
            }
            else//若存在右儿子且左val<右val 
            //(左儿子也可能不存在, 不存在的话左儿子的val就是0, 肯定<=右儿子的val(val最小为0)也符合左val<右val)
            {
                zag(p);//右大左旋
                remove(tr[p].l,key);
            }
        }
        else //不存在左右子树,是叶子节点
            p = 0;//叶子节点不用考虑平衡问题，直接删就是了
 
    }else if (tr[p].key > key)remove(tr[p].l,key);//去左侧删
    else remove(tr[p].r,key);//右侧删
    pushup(p);// 自底向上更新p的size
}
 
//没有修改,不需要引用
 
int get_rank_by_key(int p, int key)    // 通过数值找排名
{
    if (!p) return 0;
    if (tr[p].key == key) return tr[tr[p].l].size + 1;//左子树的size + 1(同样的数值中最靠左的)
    if (tr[p].key > key)return get_rank_by_key(tr[p].l,key);//大了,去左子树找
    return tr[tr[p].l].size + tr[p].cnt + get_rank_by_key(tr[p].r,key);//去右边找的时候找的是在右子树中的排名,需要加上左子树和根的cnt
}
 
int get_key_by_rank(int p, int rank)   // 通过排名找数值
{
    if(!p) return INF;
    if(tr[tr[p].l].size >= rank) return get_key_by_rank(tr[p].l,rank);
    //左边的个数>=rank,说明数值在左边
    if(tr[tr[p].l].size + tr[p].cnt >= rank)return tr[p].key;//左子树个数不够,加上当前cnt又多了,那就是当前数值
    return get_key_by_rank(tr[p].r,rank - tr[tr[p].l].size - tr[p].cnt); //去右子树中找数值,排名应该先减去左子树size+cnt
}
 
 
int get_prev(int p, int key)   // 找严格小于key的最大数
{
    if(!p) return -INF;
    if(tr[p].key >= key) return get_prev(tr[p].l,key);//当前大于key,右子树不考虑
    return max(tr[p].key,get_prev(tr[p].r,key)); //tr[p].key<key,左子树与当前key都小于key但当前key更大,考虑当前key和右子树
 
}
int get_next(int p, int key)   // 找严格大于key的最小数
{
    if(!p) return INF;
    if(tr[p].key <= key)return get_next(tr[p].r,key); //当前key小于key,左子树不考虑
    return min(tr[p].key,get_next(tr[p].l,key)); //tr[p].key>key,右子树与当前key都大于key但当前key更小,考虑当前key和左子树
}
 
int main(){
    build();
    scanf("%d",&n);
    while(n --){
        int op,x;
        scanf("%d%d",&op,&x);
        switch(op){
        	case 1:{
        		insert(root,x);
				break;
			}
        	case 2:{
        		remove(root,x);
				break;
			}
        	case 3:{
        		printf("%d\n",get_rank_by_key(root,x) - 1);//查排名,有-INF,排名要-1
				break;
			}
        	case 4:{
        		printf("%d\n",get_key_by_rank(root,x + 1));//查排名为x的数值,有-INF,内部排名为x + 1
				break;
			}
        	case 5:{
        		printf("%d\n",get_prev(root,x));
				break;
			}
        	case 6:{
        		printf("%d\n",get_next(root,x));
				break;
			}
        	default:continue;
		}
    }
    return 0;
}

 Vector版本代码：

#include <bits/stdc++.h>
using namespace std;
inline void read(int &x){
    int f=1;char c=getchar();x=0;
    while(!isdigit(c)){if(c=='-') f=-1;c=getchar();}
    while(isdigit(c)){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    x*=f;
}
int main(){
//	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int t;
	read(t);
	vector<int>v;
	while(t--){
		int op,x;
		read(op),read(x);
		if(op==1){
			v.insert(upper_bound(v.begin(),v.end(),x),x);//在迭代器指向的元素前插入
		}else if(op==2){
			v.erase(lower_bound(v.begin(),v.end(),x));//删除 找不到返回v.end()[v.end()指向最后元素的后一个迭代器] 
		}else if(op==3){
			printf("%d\n",lower_bound(v.begin(),v.end(),x)-v.begin()+1);
		}else if(op==4){
			printf("%d\n",v[x-1]);
		}else if(op==5){
			printf("%d\n",*--lower_bound(v.begin(),v.end(),x));//迭代器相当于指针，*操作取出该地址的数值 
		}else{
			printf("%d\n",*upper_bound(v.begin(),v.end(),x));
		}
	}
    return 0;
}