浅析BST二叉搜索树

2020-3-25 update: 原洛谷日报#2中代码部分出现一些问题，详情见此帖。并略微修改本文一些描述，使得语言更加自然。

2020-4-9 update：修了一些代码的锅，并且将文章同步发表于我的个人博客

同步发表于

洛谷博客

题目传送门

BST就是二叉搜索树，这里讲的是最普通的BST。

---

BST（Binary Search Tree），二叉搜索树，又叫二叉排序树

是一棵空树或具有以下几种性质的树:

1. 若左子树不空，则左子树上所有结点的值均小于它的根结点的值

2. 若右子树不空，则右子树上所有结点的值均大于它的根结点的值

3. 左、右子树也分别为二叉排序树

4. 没有权值相等的结点。

看到第4条，我们会有一个疑问，在数据中遇到多个相等的数该怎么办呢，显然我们可以多加一个计数器，就是当前这个值出现了几遍。

那么我们的每一个节点都包含以下几个信息:

1. 当前节点的权值，也就是序列里的数

2. 左孩子的下标和右孩子的下标，如果没有则为0

3. 计数器，代表当前的值出现了几遍

4. 子树大小和自己的大小的和

至于为什么要有4.我们放到后面讲。

节点是这样的:

struct node{
    int val,ls,rs,cnt,siz;
}tree[];

　　

其中val是权值，ls/rs是左/右 孩子的下标，cnt是当前的权值出现了几次，siz是子树大小和自己的大小的和

---

插入:

x是当前节点的下标，v是要插入的值

void add(int x,int v)
{
    tree[x].siz++;
    //如果查到这个节点，说明这个节点的子树里面肯定是有v的，所以siz++
    if(tree[x].val==v){
        //如果恰好有重复的数，就把cnt++，退出即可，因为我们要满足第四条性质
        tree[x].cnt++;
        return ;
    }
    if(tree[x].val>v){//如果v<tree[x].val，说明v实在x的左子树里
        if(tree[x].ls!=)
          add(tree[x].ls,v);//如果x有左子树，就去x的左子树
        else{//如果不是，v就是x的左子树的权值
            cont++;//cont是目前BST一共有几个节点
            tree[cont].val=v;
            tree[cont].siz=tree[cont].cnt=;
            tree[x].ls=cont;
        }
    }
    else{//右子树同理
        if(tree[x].rs!=)
          add(tree[x].rs,v);
        else{
            cont++;
            tree[cont].val=v;
            tree[cont].siz=tree[cont].cnt=;
            tree[x].rs=cont;
        }
    }
}

　　

---

找前驱:

x是当前的节点的下标，val是要找前驱的值，ans是目前找到的比val小的数的最大值

　　

int queryfr(int x, int val, int ans) {
    if (tree[x].val>=val)
    {//如果当前值大于val，就说明查的数大了，所以要往左子树找
        if (tree[x].ls==)//如果没有左子树就直接返回找到的ans
            return ans;
        else//如果不是的话，去查左子树
            return queryfr(tree[x].ls,val,ans);
    }
    else
    {//如果当前值小于val，就说明我们找比val小的了
        if (tree[x].rs==)//如果没有右孩子，就返回tree[x].val，因为走到这一步时，我们后找到的一定比先找到的大(参考第二条性质)
            return (tree[x].val<val) ? tree[x].val : ans
        //如果有右孩子，，我们还要找这个节点的右子树，因为万一右子树有比当前节点还大并且小于要找的val的话，ans需要更新
        if (tree[x].cnt!=)//如果当前节数的个数不为0，ans就可以更新为tree[x].val
            return queryfr(tree[x].rs,val,tree[x].val);
        else//反之ans不需要更新
            return queryfr(tree[x].rs,val,ans);
    }
}

---

找后继

与找前驱同理，只不过反过来了，在这里我就不多赘述了

int queryne(int x, int val, int ans) {
    if (tree[x].val<=val)
    {
        if (tree[x].rs==)
            return ans;
        else
            return queryne(tree[x].rs,val,ans);
    }
    else
    {
        if (tree[x].ls==)
            return (tree[x].val>val)? tree[x].val : ans;
        if (tree[x].cnt!=)
            return queryne(tree[x].ls,val,tree[x].val);
        else
            return queryne(tree[x].ls,val,ans);
    }
}

---

按值找排名:

这里我们就要用到siz了，排名就是比这个值要小的数的个数再+1，所以我们按值找排名，就可以看做找比这个值小的数的个数，最后加上1即可。

int queryval(int x,int val)
{
    if(x==) return ;//没有排名
    if(val==tree[x].val) return tree[tree[x].ls].siz+;
    //如果当前节点值=val，则我们加上现在比val小的数的个数，也就是它左子树的大小
    if(val<tree[x].val) return queryval(tree[x].ls,val);
    //如果当前节点值比val大了，我们就去它的左子树找val，因为左子树的节点值一定是小的
    return queryval(tree[x].rs,val)+tree[tree[x].ls].siz+tree[x].cnt;
    //如果当前节点值比val小了，我们就去它的右子树找val，同时加上左子树的大小和这个节点的值出现次数
    //因为这个节点的值小于val，这个节点的左子树的各个节点的值一定也小于val
}

　　

---

按排名找值:

因为性质1和性质2，我们发现排名为n的数在BST上是第n靠左的数。或者说排名为n的数的节点在BST中，它的左子树的siz与它的各个祖先的左子树的siz相加恰好=n (这里相加是要减去重复部分)。

所以问题又转化成上一段 或者说 的后面的部分

rk是要找的排名

int queryrk(int x,int rk)
{
    if(x==) return INF;
    if(tree[tree[x].ls].siz>=rk)//如果左子树大小>=rk了，就说明答案在左子树里
        return queryrk(tree[x].ls,rk);//查左子树
    if(tree[tree[x].ls].siz+tree[x].cnt>=rk)//如果左子树大小加上当前的数的多少恰好>=k，说明我们找到答案了
        return tree[x].val;//直接返回权值
    return queryrk(tree[x].rs,rk-tree[tree[x].ls].siz-tree[x].cnt);
    //否则就查右子树，同时减去当前节点的次数与左子树的大小
}

　　

---

同时还要注意一点，此题的排名是要再+1的，样例的正确输出应该是3 3 1 5

---

然后是完整版代码

Code:

#include<iostream>
#include<cstdio>
using namespace std;
const int INF=0x7fffffff;
int cont;
struct node{
    int val,ls,rs,cnt,siz;
}tree[];
int n,opt,xx;
void add(int x,int v)
{
    tree[x].siz++;
    if(tree[x].val==v){
        tree[x].cnt++;
        return ;
    }
    if(tree[x].val>v){
        if(tree[x].ls!=)
          add(tree[x].ls,v);
        else{
            cont++;
            tree[cont].val=v;
            tree[cont].siz=tree[cont].cnt=;
            tree[x].ls=cont;
        }
    }
    else{
        if(tree[x].rs!=)
          add(tree[x].rs,v);
        else{
            cont++;
            tree[cont].val=v;
            tree[cont].siz=tree[cont].cnt=;
            tree[x].rs=cont;
        }
    }
}
int queryfr(int x, int val, int ans) {
    if (tree[x].val>=val)
    {
        if (tree[x].ls==)
            return ans;
        else
            return queryfr(tree[x].ls,val,ans);
    }
    else
    {
        if (tree[x].rs==)
            return (tree[x].val<val) ? tree[x].val : ans;
        if (tree[x].cnt!=)
            return queryfr(tree[x].rs,val,tree[x].val);
        else
            return queryfr(tree[x].rs,val,ans);
    }
}
int queryne(int x, int val, int ans) {
    if (tree[x].val<=val)
    {
        if (tree[x].rs==)
            return ans;
        else
            return queryne(tree[x].rs,val,ans);
    }
    else
    {
        if (tree[x].ls==)
            return (tree[x].val>val)? tree[x].val : ans;
        if (tree[x].cnt!=)
            return queryne(tree[x].ls,val,tree[x].val);
        else
            return queryne(tree[x].ls,val,ans);
    }
}
int queryrk(int x,int rk)
{
    if(x==) return INF;
    if(tree[tree[x].ls].siz>=rk)
        return queryrk(tree[x].ls,rk);
    if(tree[tree[x].ls].siz+tree[x].cnt>=rk)
        return tree[x].val;
    return queryrk(tree[x].rs,rk-tree[tree[x].ls].siz-tree[x].cnt);
}
int queryval(int x,int val)
{
    if(x==) return ;
    if(val==tree[x].val) return tree[tree[x].ls].siz+;
    if(val<tree[x].val) return queryval(tree[x].ls,val);
    return queryval(tree[x].rs,val)+tree[tree[x].ls].siz+tree[x].cnt;
}
inline int read()
{
    int r=,w=;
    char ch=getchar();
    while(ch<''||ch>''){
        if(ch=='-') w=-;
        ch=getchar();
    }
    while(ch>=''&&ch<=''){
        r=(r<<)+(r<<)+(ch^);
        ch=getchar();
    }
    return r*w;
}
int main()
{
    n=read();
    while(n--){
        opt=read();xx=read();
        if(opt==) printf("%d\n",queryval(,xx)+);
        else if(opt==) printf("%d\n",queryrk(,xx));
        else if(opt==) printf("%d\n",queryfr(,xx,-INF));
        else if(opt==) printf("%d\n",queryne(,xx,INF));
        else{
            if(cont==){
                cont++;
                tree[cont].cnt=tree[cont].siz=;
                tree[cont].val=xx;
            }
            else add(,xx);
        }
    }
    return ;
}