BST 二叉搜索树

BST，又叫平衡二叉树，是一种循关键码访问的二叉树，每个节点带有一个数值就是关键码，并且要求保持顺序性，即任一节点不小于其左后代，不大于其右后代（注意是后代，不是孩子）。BST的顺序性使得其中序遍历序列一定是单调非降的。

BST是满足下面所给出条件的二叉树：

对于二叉检索树的任意一个结点，设其值为K，则该结点左子树中任意一个结点的值都小于K；该结点右子树中任意一个结点的值都大于或等于K。

对于一组数，将这组数的两个排列按规则插入到BST中，如果采用中序遍历将各个结点打印出来，则会得到由小到大排列的相同序列。如下图

BST的建立

为了避免越界，减少边界情况的特殊判断，我们一般在BST中额外插入一个关键码为正无穷，和一个节点关键码为负无穷，

仅由这两个节点构成的BST就是一棵初始的空BST.。

CODE：

struct BST{
    int l,r;//左右子节点在数组中的下标
    int val;//节点关键码 
}a[SIZE];//数组模拟链表
int tot,root,INF=1<<30;
int New(int val)
{
    a[++tot].val=val;
    return tot;
} 
void build()
{
    New(-INF);New(INF);
    root=1;a[1].r=2;
}

BST的检索

在BST中检索是否存在关键码为val的节点。

设变量p等于根节点root，执行以下过程：

1，若P的关键码等于val，则已经找到。

2，若p的关键码大于val

（1）若p的子节点为空，则说明不存在val.

（2）否则，在p的左子树中进行递归检索。

3，若p的关键码小于val

（1）若p的右子节点为空，则说明不存在val.

（2）否则，在p的右子树中进行递归检索。

CODE：

int Get(int p,int val)
{
    if(p==0)return 0;//检索失败 
    if(val==a[p].val)return p;//检索成功
    return val<a[p].val?Get(a[p].l,val):Get(a[p].r,val); 
}

BST的插入：

与检索过程相似，发现要走向的p的子节点为空，说明val不存在，直接建立关键码为val的新节点作为p的子节点。

CODE：

void Insert(int &p,int val)
{
    if(p==0)
    {
        p=New(val);//注意p是引用，起父节点的l或r值会被同时更新 
        return;
    }
    if(val==a[p].val)return;
    if(val<a[p].val)Insert(a[p].l,val);
    else Insert(a[p].r,val);
} 

求前驱/后继

前驱就是在BST中关键码小于val的最大节点，

后继就是在BST中关键码大于val的最小节点，

先检索找val，检索后有三种结果：

1，没有找到val。此时val的后继就在已经经过的节点中，ans即为所求。

2，找到了关键码为val的节点p，但是p没有右子树，情况与上一中相同，ans即为所求。

3，找到了关键码为val的节点p，且p右子树，从p的右子树出发一直向左走，就找到了val的后继。

CODE：

求前驱：

int GetNext(int val)
{
    int ans=2;
    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 ans;
}

求后继：

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=val<a[p].val?a[p].l:a[p].r; 
    }
    return ans;
}

BST的节点删除：

BST的删除有些复杂，分为两种情况：

（1）删除的节点没有左孩子或者是没有右孩子，此时直接把另一个非空的子节点取代删除节点即可。

 

（2）删除的节点既有左孩子，也有右孩子

为了保证BST的顺序性，此时应该用待删除节点的下一个节点（指中序序列中）取代待删除节点，并且调整节点间的父子关系。

这里用引用会好写一点直接改上一步的节点、

CODE：

void Remove(int val)
{
    //检索val，得到节点p
    int &p=root;
    while(p)
    {
        if(val==a[p].val)
            break;
        p=val<a[p].val?a[p].l:a[p].r;
    } 
    if(p==0)
        return;
    if(a[p].l==0)//没有左子树 
    {
        p=a[p].r;//右子树代替p的位置，注意p是引用 
    }
    else if(a[p].r==0)//没有右子树 
    {
        p=a[p].l;//左子树代替p的位置，注意p是引用 
    }
    else//既有左子树又有右子树 
    {
        //求后继节点
        int next=a[p].r;
        while(a[next].l>0)
        next=a[next].l;
        //next一定没有左子树，直接删除
        Remove(a[next].val);
        a[next].l=a[p].l,a[next].r=a[p].r;
        p=next;//注意p是引用 
    }
}