二叉排序树的基本操作

题目描述

二叉排序树或者是一棵空树，或者是具有以下几条性质的二叉树：

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

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

3.       它的左右子树也分别为二叉排序树。

二叉排序树又可以被称为二叉查找树，根据上述定义的结构不难知道，它的查找过程十分简单，只需要通过不断的将当前结点的值与需要查找的值进行比较，如果相等则直接输出，如果要查找的值更小则深入至左子树进行比较，否则就深入右子树进行比较，直到找到相应的值或者进入了一棵不存在的子树为止。

其查找过程可以描述如下：

而其插入过程同样也十分简洁，可以描述如下：

而删除操作可以描述为如下的两个算法：

在本题中，读入一串整数，首先利用这些整数构造一棵二叉排序树。另外给定多次查询，利用构造出的二叉排序树，判断每一次查询是否成功。

输入

输入的第一行包含2个正整数n和k，分别表示共有n个整数和k次查询。其中n不超过500，k同样不超过500。 第二行包含n个用空格隔开的正整数，表示n个整数。 第三行包含k个用空格隔开的正整数，表示k次查询的目标。

输出

只有1行，包含k个整数，分别表示每一次的查询结果。如果在查询中找到了对应的整数，则输出1，否则输出0。 请在每个整数后输出一个空格，并请注意行尾输出换行。

样例输入

8 31 3 5 7 8 9 10 159 2 5

样例输出

1 0 1

#include<cstdio>
#include<iostream>
#include<malloc.h>
#define LH +1
#define EH 0
#define RH -1
#define NULL 0
using namespace::std;
typedef struct BiTNode{
    int data;//数据
    int bf;//平衡因子
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void R_Rotate(BiTree *p){
    BiTree L;
    L=(*p)->lchild;
    (*p)->lchild=L->rchild;
    L->rchild=(*p);
    *p=L;
}
void L_Rotate(BiTree *p){
    BiTree R;
    R=(*p)->rchild;
    (*p)->rchild=R->lchild;
    R->lchild=(*p);
    *p=R;
}
void LeftBalance(BiTree *T){
    BiTree L,Lr;
    L=(*T)->lchild;
    switch(L->bf){
    case LH:
            (*T)->bf=L->bf=EH;
            R_Rotate(T);
            break;
        case RH:
            Lr=L->rchild;
            switch(Lr->bf){
                case LH:
                    (*T)->bf=RH;
                    L->bf=EH;
                    break;
                case EH:
                    (*T)->bf=L->bf=EH;
                    break;
                case RH:
                    (*T)->bf=EH;
                    L->bf=LH;
                    break;
            }
            Lr->bf=EH;
            L_Rotate(&(*T)->lchild);
            R_Rotate(T);
            break;
    }
}
void RightBalance(BiTree *T){
    BiTree R,Rl;
    R=(*T)->rchild;
    switch(R->bf){
        case RH:
            (*T)->bf=R->bf=EH;
            L_Rotate(T);
            break;
        case LH:
            Rl=R->lchild;
            switch(Rl->bf){
            case RH:
                (*T)->bf=LH;
                R->bf=EH;
                break;
            case EH:
                (*T)->bf=R->bf=EH;
                break;
            case LH:
                (*T)->bf=EH;
                R->bf=RH;
                break;
            }
            Rl->bf=EH;
            R_Rotate(&(*T)->lchild);
            L_Rotate(T);
    }
}
int InsertAVL(BiTree *T,int e,int *taller){
    if(!*T){
        *T=(BiTree)malloc(sizeof(BiTNode));
        (*T)->data=e;
        (*T)->lchild=(*T)->rchild=NULL;
        (*T)->bf=EH;
        *taller=1;
    }
    else{
        if(e==(*T)->data){
            *taller=0;
            return 0;
        }
        if(e<(*T)->data){
            if(!InsertAVL(&(*T)->lchild,e,taller))
                return 0;
            if(taller){
                switch((*T)->bf){
                    case LH:
                        LeftBalance(T);
                        *taller=0;
                        break;
                    case EH:
                        (*T)->bf=LH;
                        *taller=1;
                        break;
                    case RH:
                        (*T)->bf=LH;
                        *taller=0;
                        break;
                }
            }
        }
        else{
            if(!InsertAVL(&(*T)->rchild,e,taller))
                return 0;
            if(taller){
                switch((*T)->bf){
                case LH:
                    (*T)->bf=EH;
                    *taller=0;
                    break;
                case EH:
                    (*T)->bf=RH;
                    *taller=1;
                    break;
                case RH:
                    RightBalance(T);
                    *taller=0;
                    break;
                }
            }
        }
    }
    return 0;
}
int SearchBT(BiTree *T,int e){
    if(e==(*T)->data)
        return 1;
    else if(e<(*T)->data){
        if((*T)->lchild!=NULL)
        SearchBT(&(*T)->lchild,e);
        else return 0;
    }
    else if(e>(*T)->data){
        if((*T)->rchild!=NULL)
        SearchBT(&(*T)->rchild,e);
        else return 0;
    }
}
int main(){
    int n,k;
    int i,j;
    while(~scanf("%d%d",&n,&k)){
        BiTree T=NULL;
        int taller=0;
        int e;
        while(n--){
            scanf("%d",&e);
            InsertAVL(&T,e,&taller);
        }
        while(k--){
            scanf("%d",&e);
            if(SearchBT(&T,e))
                cout<<1<<" ";
            else
                cout<<0<<" ";
        }
        cout<<endl;
    }
    return 0;
}