权值线段树

权值线段树，每个叶子结点都视为点的权值，在进行操作时要离散

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：
1. 插入x数
2. 删除x数(若有多个相同的数，因只删除一个)
3. 查询x数的排名(若有多个相同的数，因输出最小的排名)
4. 查询排名为x的数
5. 求x的前驱(前驱定义为小于x，且最大的数)
6. 求x的后继(后继定义为大于x，且最小的数)

Input

第一行为n，表示操作的个数,下面n行每行有两个数opt和x，opt表示操作的序号(1<=opt<=6)

Output

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

Sample Input

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

Sample Output
    106465
    84185
    492737
Hint

    1.n的数据范围：n<=100000

    2.每个数的数据范围：[-2e9,2e9]

代码示例 :

#define ll long long
const ll maxn = 1e5+5;
const ll mod = 1e9+7;
const double eps = 1e-9;
const double pi = acos(-1.0);
const ll inf = 0x3f3f3f3f;
#define lson k<<1
#define rson k<<1|1

struct pp
{
    ll pt, x;
}pre[maxn];
ll s[maxn];
ll k = 1;
struct node
{
    ll l, r;
    ll num; // ge shu
}t[maxn<<2];

void build(ll l, ll r, ll k){ 
    t[k].l = l, t[k].r = r;
    t[k].num = 0;
    
    if (l == r) return;
    ll m = (l+r)>>1;
    build(l, m, lson);
    build(m+1, r, rson);
}

void pushup(ll k){
    t[k].num = t[lson].num+t[rson].num;
}

void update(ll pos, ll pt, ll k){
    if (t[k].l == t[k].r){
        //prllf("l = %d r = %d pos = %d 
", t[k].l, t[k].r, pos);
        if (t[k].num + pt >= 0) t[k].num += pt; 
        return;
    }
    ll m = (t[k].l+t[k].r)>>1;
    if (pos <= m) update(pos, pt, lson);
    else update(pos, pt, rson);
    pushup(k);
}

ll ans = 0;
void query3(ll l, ll r, ll k){
    if (l <= t[k].l && t[k].r <= r){ 
        ans += t[k].num;
        return;
    }
     
    ll m = (t[k].l+t[k].r)>>1;
    if (l <= m) query3(l, r, lson);
    if (r > m) query3(l, r, rson);
}

void query4(ll x, ll k){
    //printf("^^ %lld %lld 
", t[k].l, t[k].r);
    if (t[k].l == t[k].r){
        ans = t[k].l;
        return;
    }
    ll m = (t[k].l+t[k].r)>>1;
    if (t[lson].num >= x) query4(x, lson);
    else query4(x-t[lson].num, rson);
}

int main() {
    //freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    ll n;
    
    cin >> n;
    
    for(ll i = 1; i <= n; i++){
        scanf("%lld%lld", &pre[i].pt, &pre[i].x);
        if (pre[i].pt != 4) s[k++] = pre[i].x;     
    }
    sort(s+1, s+k);
    k = unique(s+1, s+k)-s;
    //for(int i = 1; i < k; i++) printf("%lld ", s[i]);
    build(1, n, 1); 
    for(ll i = 1; i <= n; i++){
        ll x = lower_bound(s+1, s+k, pre[i].x)-s;
        //printf("____ %lld %lld
", x, pre[i].x);
        ans = 0;
        if (pre[i].pt == 1){
            update(x, 1, 1);            
        }
        else if (pre[i].pt == 2) {
            update(x, -1, 1);
        }
        else if (pre[i].pt == 3){
            query3(1, x-1, 1);
            printf("%lld
", ans+1);
        }
        else if (pre[i].pt == 4){
            query4(pre[i].x, 1);
            printf("%lld
", s[ans]);
        }
        else if (pre[i].pt == 5){
            query3(1, x-1, 1);
            query4(ans, 1);
            printf("%lld
", s[ans]);
        }
        else {
            query3(1, x, 1);
            //printf("--- %d
", ans);
            query4(ans+1, 1);
            printf("%lld
", s[ans]);
        } 
    }
    return 0;
}