#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct TNode *Position;
typedef Position BinTree;

struct TNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

void PreorderTraversal( BinTree BT );
void InorderTraversal( BinTree BT );
void PostorderTraversal(BinTree BT);

BinTree Insert( BinTree BST, ElementType X );
BinTree Delete( BinTree BST, ElementType X );
Position Find( BinTree BST, ElementType X );
Position FindMin( BinTree BST );
Position FindMax( BinTree BST );

int main()
{
    BinTree BST, MinP, MaxP, Tmp;
    ElementType X;
    int N, i;

    BST =
 
 NULL;
    scanf("%d", &N);
    for ( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Insert(BST, X);
    }
    printf("Inorder:"); InorderTraversal(BST); printf("\n");
    printf("Preorder:"); PreorderTraversal(BST); printf("\n");
    printf("Postorder:"); PostorderTraversal(BST); printf("\n"
 
);
    MinP = FindMin(BST);
    MaxP = FindMax(BST);
    scanf("%d", &N);
    for( i=0; i<N; i++ ) {
        scanf("%d", &X);
        Tmp = Find(BST, X);
        if (Tmp == NULL) printf("%d is not found\n", X);
        else {
            printf("%d is found\n", Tmp->Data);
            if
 
 (Tmp==MinP) printf("%d is the smallest key\n", Tmp->Data);
            if (Tmp==MaxP) printf("%d is the largest key\n", Tmp->Data);
        }
    }
    scanf("%d", &N);
    for( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Delete(BST, X);
    }
    printf("Inorder:"); InorderTraversal(BST); printf("\n");
    printf("Preorder:"); PreorderTraversal(BST); printf("\n");
    return 0;
}



BinTree Insert( BinTree BST, ElementType X ){
    if(!BST){
        //若原樹為空，生成並返回一個節點的二叉搜尋樹
        //printf("插入%d\n", X);
        BST = (Position)malloc(sizeof(struct TNode));
        BST -> Data = X;
        BST -> Left = BST -> Right = NULL;
    }else{
        if(X < BST -> Data)
            BST -> Left = Insert(BST -> Left, X);
        else if(X > BST -> Data)
            BST -> Right = Insert(BST -> Right, X);
    }
    return BST;
}
BinTree Delete( BinTree BST, ElementType X ){
    Position Tmp;
    if(!BST)  printf("Not Found\n");
    else{
        if(X < BST -> Data)
            BST -> Left = Delete( BST -> Left , X);
        else if(X > BST -> Data)
            BST -> Right = Delete(BST -> Right, X);
        else
            if(BST -> Left && BST -> Right){    //被刪除節點有左右兩個子節點
                Tmp = FindMin(BST -> Right);
                BST -> Data = Tmp -> Data;
                BST -> Right = Delete(BST -> Right, BST -> Data);
            }else {             //在刪除節點的右子樹中的刪除最小節點
                Tmp = BST;
                if(!BST -> Left)    //有右孩子或無子節點
                    BST = BST -> Right;
                else if(!BST -> Right)  //有左孩子或無子節點
                    BST = BST -> Left;
                free(Tmp);
            }
    }

    return BST;
}
Position Find( BinTree BST, ElementType X ){
    if(!BST) return NULL;
    if(X > BST -> Data)
        return Find(BST -> Right, X);
    else if(X < BST -> Data)
        return Find(BST -> Left, X);
    else
        return BST;
}
Position FindMin( BinTree BST ){
    if(!BST) return NULL;
    else if(!BST -> Left)
        return BST;
    else
        return FindMin(BST -> Left);
}
Position FindMax( BinTree BST ){
    if(BST)
        while(BST -> Right) BST = BST -> Right;
    return BST;
}


void PreorderTraversal( BinTree BT ){
    if(BT == NULL) return ;
    printf("%d ", BT -> Data);
    PreorderTraversal(BT -> Left);
    PreorderTraversal(BT -> Right);
}

void InorderTraversal( BinTree BT ){
    if(BT == NULL) return ;
    InorderTraversal(BT -> Left);
    printf("%d ", BT -> Data);
    InorderTraversal(BT -> Right);
}
void PostorderTraversal( BinTree BT ){
    if(BT == NULL) return ;
    PostorderTraversal(BT -> Left);
    PostorderTraversal(BT -> Right);
    printf("%d ", BT -> Data);
}