普通平衡树

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：

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每行输出一个数，表示对应答案。

数据范围
n≤100000,所有数均在−10^ 7到10^7内。

输入样例：
8
1 10
1 20
1 30
3 20
4 2
2 10
5 25
6 -1
输出样例：
2
20
20
20

数据水

#include 

using namespace std;
vector<int> a;
int n, op, x;

int main() {
    scanf("%d", &n);
    while (n--) {
        scanf("%d%d", &op, &x);
        switch (op) {
            case 1:
                a.insert(lower_bound(a.begin(), a.end(), x), x);
                break;
            case 2:
                a.erase(lower_bound(a.begin(), a.end(), x));
                break;
            case 3:
                printf("%d\n", lower_bound(a.begin(), a.end(), x) - a.begin() + 1);
                break;
            case 4:
                printf("%d\n", a[x - 1]);
                break;
            case 5:
                printf("%d\n", *--lower_bound(a.begin(), a.end(), x));
                break;
            default:
                printf("%d\n", *upper_bound(a.begin(), a.end(), x));
        }
    }
    return 0;
}

Treap

#include 

using namespace std;
const int N = 1e5 + 10, INF = 0x7fffffff;
struct Treap {
    int l, r;
    int val, dat;
    int cnt, size;
} a[N];
int tot, root, n, op, x;

int New(int val) {
    a[++tot].val = val;
    a[tot].dat = rand();
    a[tot].cnt = a[tot].size = 1;
    return tot;
}

void Update(int p) {
    a[p].size = a[a[p].l].size + a[a[p].r].size + a[p].cnt;
}

void Build() {
    New(-INF), New(INF);
    root = 1, a[1].r = 2;
    Update(root);
}

int GetRankByVal(int p, int val) {
    if (p == 0)return 0;
    if (val == a[p].val)return a[a[p].l].size + 1;
    if (val < a[p].val)return GetRankByVal(a[p].l, val);
    return GetRankByVal(a[p].r, val) + a[a[p].l].size + a[p].cnt;
}

int GetValByRank(int p, int rank) {
    if (p == 0)return INF;
    if (a[a[p].l].size >= rank)return GetValByRank(a[p].l, rank);
    if (a[a[p].l].size + a[p].cnt >= rank)return a[p].val;
    return GetValByRank(a[p].r, rank - a[a[p].l].size - a[p].cnt);
}

void zig(int &p) {
    int q = a[p].l;
    a[p].l = a[q].r, a[q].r = p, p = q;
    Update(a[p].r), Update(p);
}

void zag(int &p) {
    int q = a[p].r;
    a[p].r = a[q].l, a[q].l = p, p = q;
    Update(a[p].l), Update(p);
}

void Insert(int &p, int val) {
    if (p == 0) {
        p = New(val);
        return;
    }
    if (val == a[p].val) {
        a[p].cnt++, Update(p);
        return;
    }
    if (val < a[p].val) {
        Insert(a[p].l, val);
        if (a[p].dat < a[a[p].l].dat)zig(p);
    } else {
        Insert(a[p].r, val);
        if (a[p].dat < a[a[p].r].dat)zag(p);
    }
    Update(p);
}

int GetPre(int val) {
    int ans = 1;
    int p = root;
    while (p) {
        if (val == a[p].val) {
            if (a[p].l > 0) {
                p = a[p].l;
                while (a[p].r > 0)p = a[p].r;
                ans = p;
            }
            break;
        }
        if (a[p].val < val && a[p].val > a[ans].val)ans = p;
        p = val < a[p].val ? a[p].l : a[p].r;
    }
    return a[ans].val;
}

int GetNext(int val) {
    int ans = 2;
    int p = root;
    while (p) {
        if (val == a[p].val) {
            if (a[p].r > 0) {
                p = a[p].r;
                while (a[p].l > 0)p = a[p].l;
                ans = p;
            }
            break;
        }
        if (a[p].val > val && a[p].val < a[ans].val)ans = p;
        p = p = val < a[p].val ? a[p].l : a[p].r;
    }
    return a[ans].val;
}

void Remove(int &p, int val) {
    if (p == 0)return;
    if (val == a[p].val) {
        if (a[p].cnt > 1) {
            a[p].cnt--, Update(p);
            return;
        }
        if (a[p].l || a[p].r) {
            if (a[p].r == 0 || a[a[p].l].dat > a[a[p].r].dat)
                zig(p), Remove(a[p].r, val);
            else
                zag(p), Remove(a[p].l, val);
            Update(p);
        } else p = 0;
        return;
    }
    val < a[p].val ? Remove(a[p].l, val) : Remove(a[p].r, val);
    Update(p);
}


int main() {
    Build();
    scanf("%d", &n);
    while (n--) {
        scanf("%d%d", &op, &x);
        switch (op) {
            case 1:
                Insert(root, x);
                break;
            case 2:
                Remove(root, x);
                break;
            case 3:
                printf("%d\n", GetRankByVal(root, x) - 1);
                break;
            case 4:
                printf("%d\n", GetValByRank(root, x + 1));
                break;
            case 5:
                printf("%d\n", GetPre(x));
                break;
            default:
                printf("%d\n", GetNext(x));
        }
    }
    return 0;
}