算法提高-平衡树

常用的平衡树如下：
用的最多的就是treap和splay，后者在进阶课说

treap是一种特殊的二叉搜索树(BST)，BST可以做的事情treap都可以。treap相当于一个BST+Heap，treap上的Node比BST多维护一个信息——Heap的val，即他的key既要满足BST（他key大于左节点且小于右节点）他的val也要满足Heap（this.val大于左子节点和右节点的val）。
这里的val是一个随机值，key+val的组合可以让我们这颗树变成一个唯一确定的二叉搜索树：比如我要找根节点，我直接找val最大的节点，那么又因为BST当前节点的左边的key一定小于当前节点，当前节点的右边的key一定大于当前节点，可以让我们整个递归过程是一个有序的。
val是一个随机值，加上heap这个数据结构是为了BST的递归变成一个可控的有序的过程。并且保证这是一颗二叉树的结构防止退化成一条链，保证了时间复杂度为logn

查找插入删除操作其实就是模拟树上二分，每次去掉当前的一半，因此是log₂N的时间复杂度

AcWing 253. 普通平衡树

#include<iostream>
#include <algorithm>
using namespace std;
const int N = 1e6 + 10, INF = 1e8;
int n;
struct Node{
    int l, r;
    int key, val;
    int cnt, size;
}tr[N];
int idx, root;

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();
    tr[idx].cnt = tr[idx].size = 1;
    return idx;
}

void zig(int &p)//右旋
{
    int q = tr[p].l;
    tr[p].l = tr[q].r; tr[q].r = p; p = q;//改变了p的值，所以p需要引用
    pushup(tr[p].r);
    pushup(p);
}

void zag(int &p)//左旋
{
    int q = tr[p].r;
    tr[p].r = tr[q].l;tr[q].l = p;p = q;
    pushup(tr[p].l);
    pushup(p);
}
void build()
{
    get_node(-INF), get_node(INF);
    root = 1, tr[1].r = 2;
    pushup(root);
    if (tr[1].val < tr[tr[1].r].val) zag(root);
}

void insert(int &p, int key)
{
    if (!p) p = get_node(key);
    else if (tr[p].key == key) tr[p].cnt ++;
    else if (tr[p].key > key)
    {
        insert(tr[p].l, key);
        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);
    
}

void remove(int &p, int key)
{
    if (!p) return ;
    else 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].r].val < tr[tr[p].l].val)//如果右子树为空或者左子树val大于右子树，但是我也不知道后面这个啥意思为啥优先删val小的
          {
                zig(p);//将p旋转到右子树进行删除（目的是将它旋转到叶子结点好删除这个节点）
                remove(tr[p].r, key);
          }
          else
          {
                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);
}

//下面就不需要引用了，直接遍历
int get_rank_by_key(int p, int key)
{
    if (!p) return 0;
    else if (tr[p].key == key) return tr[tr[p].l].size + 1;
    else if (tr[p].key < key) return get_rank_by_key(tr[p].r, key) + tr[tr[p].l].size + tr[p].cnt;
    else return get_rank_by_key(tr[p].l, key);
}
int get_key_by_rank(int p, int rank)
{
    if (!p) return -INF;
    else if (tr[tr[p].l].size >= rank) return get_key_by_rank(tr[p].l, rank);
    else if (tr[tr[p].l].size + tr[p].cnt >= rank) return tr[p].key;
    else return get_key_by_rank(tr[p].r, rank - tr[tr[p].l].size - tr[p].cnt);
}

int get_pre(int p, int key)//找严格小于key的最大值
{
    if(!p) return -INF;//前面的肯定是-INF
    else if(tr[p].key >= key) return get_pre(tr[p].l, key);
    else return max(tr[p].key, get_pre(tr[p].r, key));
}
int get_next(int p, int key)//找严格大于key的最小值
{
    if (!p) return INF;//后面的肯定是INF
    else if (tr[p].key <= key) return get_next(tr[p].r, key);
    else return min(tr[p].key, get_next(tr[p].l, key));
}
void solve()
{
    build();
    cin >> n;
    int op, x, res;
    while (n -- )
    {
        cin >> op >> x;
        if (op == 1)    insert(root, x);
        else if (op == 2)   remove(root, x);
        else if (op == 3)   cout << get_rank_by_key(root, x) - 1<< endl;//加1减1是因为初始化到了用到了2
        else if (op == 4)   cout << get_key_by_rank(root, x + 1) << endl;
        else if (op == 5)   cout << get_pre(root, x) << endl;
        else cout << get_next(root, x) << endl;
        
        
    }
}
int main()
{
    solve();
    return 0;
}