題目描述

二叉排序樹或者是一棵空樹，或者是具有以下幾條性質的二叉樹： 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;
}