BST二叉搜索树

宏定义

• #define BST_T int：以 $\text{BST\_T}$ 为基本类型维护，可根据自己需要定义，这里实现了以 $\text{int}$ 为基本类型的二叉搜索树。
• #define pl a[p].l：二叉搜索树中左子树的简写。
• #define pr a[p].r：二叉搜索树中右子树的简写。
• #define pv a[p].val：a[p].val 的简写。
• #define pc a[p].cnt：a[p].cnt 的简写。
• #define ps a[p].size：a[p].size 的简写。

常量与变量

• $\text{const BST\_T}$ MAX：一个极值，能保证值为 $MAX$ 的节点的右子树没有元素。
• $\text{const BST\_T}$ MIN：一个极值，能保证值为 $MIN$ 的节点的左子树没有元素。
• $\text{int}$ tot：实际存在的节点个数，初始时有两个节点$MIN$ 和 $MAX$。
• $\text{int}$ root：二叉搜索树的根节点，一般为 $1$。
• $\text{Tree}$ a[i]：二叉搜索树的一个节点 $i$。
• $\text{int}$ a[i].l：节点 $i$ 的左子节点，没有则为 $0$。
• $\text{int}$ a[i].r：节点 $i$ 的右子节点，没有则为 $0$
• $\text{BST\_T}$ a[i].val：节点 $i$ 的值。
• $\text{int}$ a[i].cnt：与节点 $i$ 的值相同的元素个数，都合并在 $a_i$ 中。
• $\text{int}$ a[i].size：以节点 $i$ 为根的子树的元素总数（值相同的不算作一个）。

函数

• $\text{int}$ compare(BST_T x,BST_T y)：比较 $x$ 与 $y$ 的值，可根据需要自己定义。若返回值是一个负整数，如 $-1$，则表示 $x$ 的值应该位于值为 $y$ 的节点的左子树；若返回值是 $0$，则表示 $x$ 的值应该和 $y$ 属于同一个节点；若返回值是一个正整数，如 $1$，则表示 $x$ 的值应该位于值为 $y$ 的节点的右子树。
• $\text{void}$ update(int p)：更新 $p$ 节点的 $a_p.size$。
• $\text{int}$ get_new(BST_T val)：新建一个值为 $val$ 的节点，返回这个节点的编号。
• $\text{void}$ build()：重建树，原树的信息只会从头开始覆盖，不会清除。
• $\text{int}$ get(int p,BST_T val)：找到以 $p$ 为根的子树中值为 $val$ 的节点的编号，没有则返回值为 $0$，调用时 $p$ 常为 $root$。
• $\text{void}$ insert(int &p,BST_T val)：在以 $p$ 为根的子树中插入一个值为 $val$ 的元素，计重，调用时 $p$ 常为 $root$。
• $\text{void}$ remove(int &p,BST_T val)：在以 $p$ 为根的子树中删除一个值为 $val$ 的元素，重复的只删一个，调用时 $p$ 常为 $root$。
• $\text{int}$ get_pre(BST_T val)：找到二叉搜索树中值为 $val$ 的元素的前驱的节点编号，即小于 $val$ 的数中最大的元素值的节点编号，不存在则返回值为 $MIN$ 的节点的编号 $1$。
• $\text{int}$ get_next(BST_T val)：找到二叉搜索树中值为 $val$ 的元素的后继的节点编号，即大于 $val$ 的数中最小的元素值的节点编号，不存在则返回值为 $MAX$ 的节点的编号 $2$。
• $\text{int}$ V_to_R(int p,BST_T val)：在以 $p$ 为根的子树中寻找值为 $val$ 的元素的排名，不存在则返回 $0$，排名就是小于 $val$ 后继的元素个数，调用时 $p$ 常为 $root$。
• $\text{BST\_T}$ R_to_V(int p,int rank)：在以 $p$ 为根的子树中寻找排名为 $rank-1$ 的元素的值，不存在则返回 $MAX$，一个元素的排名可能有多个，调用时 $p$ 常为 $root$。
• $\text{void}$ write(int p)：输出以 $p$ 节点为根节点的子树的信息，按先序遍历输出，每个节点的信息包括：该节点编号，该节点值，左子节点编号及值（无则均为 $0$），右子节点编号及值（无则均为 $0$）。

每次操作的时间复杂度最差为 $O(n)$，建议用于改成平衡树板子。

#define BST_T int
#define pl a[p].l
#define pr a[p].r
#define pv a[p].val
#define pc a[p].cnt
#define ps a[p].size
struct BST{
    const BST_T MAX=0x7f7f7f7f,MIN=-0x7f7f7f7f;
    int tot,root;
    struct Tree{
        int l,r;
        BST_T val;
        int cnt,size;
    }a[N];
    int compare(BST_T x,BST_T y){
        if(x<y)
            return -1;
        if(x==y)
            return 0;
        if(x>y)
            return 1;
    }
    void update(int p){
        ps=a[pl].size+a[pr].size+pc;
    }
    int get_new(BST_T val){
        a[++tot].val=val;
        a[tot].cnt=a[tot].size=1;
        a[tot].l=a[tot].r=0;
        return tot;
    }
    void build(){
        tot=0;
        get_new(MIN);get_new(MAX);
        a[root=1].r=2;
        update(root);
    }
    int get(int p,BST_T val){
        if(!p)
            return 0;
        if(!compare(val,pv))
            return p;
        return get((compare(val,pv)<0?pl:pr),val);
    }
    void insert(int &p,BST_T val){
        if(!p){
            p=get_new(val);
            return;
        }
        if(!compare(val,pv)){
            pc++;
            update(p);
            return;
        }
        if((compare(val,pv)<0))
            insert(pl,val);
        else
            insert(pr,val);
        update(p);
    }
    void remove(int &p,BST_T val){
        if(p==0)
            return;
        if(!compare(val,pv)){
            if(pc>1){
                pc--;
                update(p);
                return;
            }
            if(!pl)
                p=pr;
            else if(!pr)
                p=pl;
            else{
                int next=pr;
                while(a[next].l)
                    next=a[next].l;
                remove(pr,a[next].val);
                a[next].l=pl;
                a[next].r=pr;
                p=next;
            }
            update(p);
            return;
        }
        if((compare(val,pv)<0)) 
            remove(pl,val);
        else
            remove(pr,val);
        update(p);
    }
    int get_pre(BST_T val){
        int ans=1,p=root;
        while(p){
            if(!compare(val,pv)){
                if(pl){
                    p=pl;
                    while(pr)
                        p=pr;
                    ans=p; 
                }
                break;
            }
            if((compare(pv,val)<0&&compare(pv,a[ans].val)>0))
                ans=p;
            p=(compare(val,pv)<0?pl:pr);
        }
        return ans;
    }
    int get_next(BST_T val){
        int ans=2,p=root;
        while(p){
            if(!compare(val,pv)){
                if(pr){
                    p=pr;
                    while(pl)
                        p=pl;
                    ans=p;
                }
                break;
            }
            if((compare(pv,val)>0&&compare(pv,a[ans].val)<0))
                ans=p;
            p=(compare(val,pv)<0?pl:pr);
        }
        return ans;
    }
    int V_to_R(int p,BST_T val){//val to rank
        if(!p)
            return 0;
        if(!compare(val,pv))
            return a[pl].size;
        if(compare(val,pv)<0)
            return V_to_R(pl,val);
        return V_to_R(pr,val)+a[pl].size+pc;
    }
    BST_T R_to_V(int p,int rank){//rank to val
        if(!p)
            return MAX;
        if(a[pl].size>=rank)
            return R_to_V(pl,rank);
        if(a[pl].size+pc>=rank)
            return pv;
        return R_to_V(pr,rank-a[pl].size-pc);
    }
    void write(int p){
    	if(!p)
    		return;
    	printf("%d  val:%d  lson:%d %d  rson:%d %d\n",p,pv,pl,a[pl].val,pr,a[pr].val);
    	write(pl);write(pr);
	}
}tree;