二叉搜索树的操作集（30 分）

#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 );  /* 中序遍历，由裁判实现，细节不表 */

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("Preorder:"); PreorderTraversal(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");
    return 0;
}
Position newNode(ElementType x){
    BinTree tmp = (BinTree)malloc(sizeof(struct TNode));
    tmp->Data=x;
    tmp->Left=tmp->Right=NULL;
    return tmp;
}
BinTree Insert( BinTree BST, ElementType X ){
    if(BST==NULL){
        return newNode(X);
    }
    BinTree tmp = BST;
    int flag=0;
    while(1){
        if(tmp->Data==X)
            return BST;
        else if(tmp->Data>X){
            if(tmp->Left)
                tmp=tmp->Left;
            else{
                flag=-1;
                break;
            }
        }
        else{
            if(tmp->Right)
                tmp=tmp->Right;
            else{
                flag=1;
                break;
            }
        }

    }
    BinTree n = newNode(X);
    if(flag==-1)
        tmp->Left=n;
    else
        tmp->Right=n;
    return BST;
}
BinTree Delete( BinTree BST, ElementType X ){
    BinTree tmp;
    if(BST==NULL){
        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 = FindMax(BST->Left);
            BST->Data = tmp->Data;
            BST->Left = Delete(BST->Left,tmp->Data);
        } //有一个或者没有儿子
        else{
            tmp = BST;
            if(!BST->Left){
                BST = BST->Right;
            }
            else{
                BST = BST->Left;
            }
            free(tmp);
        }
    }
    return BST;
}
Position Find( BinTree BST, ElementType X ){
    if(BST==NULL)
        return NULL;
    if(BST->Data>X)
        Find(BST->Left,X);
    else if(BST->Data<X)
        Find(BST->Right,X);
    else
        return BST;
}
Position FindMin( BinTree BST ){
    if(!BST)
        return NULL;
    while(1){
        if(!BST->Left){
            return BST;
        }
        BST=BST->Left;
    }
}
Position FindMax( BinTree BST ){
    if(!BST)
        return NULL;
    while(1){
        if(!BST->Right){
            return BST;
        }
        BST=BST->Right;
    }
}
void PreorderTraversal( BinTree BT ){
    if(BT){
        printf("%d ",BT->Data);
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
}
void InorderTraversal( BinTree BT ){
    if(BT){
        InorderTraversal(BT->Left);
        printf(" %c",BT->Data);
        InorderTraversal(BT->Right);
    }
}