数据结构----二叉搜索树

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 百度百科

• 函数Insert将X插入二叉搜索树BST并返回结果树的根结点指针；
• 函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；如果X不在树中，则打印一行Not Found并返回原树的根结点指针；
• 函数Find在二叉搜索树BST中找到X，返回该结点的指针；如果找不到则返回空指针；
• 函数FindMin返回二叉搜索树BST中最小元结点的指针；

函数FindMax返回二叉搜索树BST中最大元结点的指针。

  1 #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 ) {    
    if(BT){
        printf(" %d ",BT->Data);
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
}
void InorderTraversal( BinTree BT ){    
    if(BT){
        InorderTraversal(BT->Left);
        printf(" %d ",BT->Data);
        InorderTraversal(BT->Right);
    }
}
  /* 中序遍历，由裁判实现，细节不表 */

BinTree Insert( BinTree BST, ElementType X ){
    //printf("插入%d
",X);
    BinTree new_node = NULL;
    if(BST==NULL){
        //printf("建立根
");
        BST = (Position)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = NULL;
        BST->Right = NULL;
    }else{
        //printf("有根了
");
        if(X < BST->Data){
            //printf("在根的左边
");
            if(BST->Left){
                Insert(BST->Left,X);
            }else{
                BinTree new_node = (Position)malloc(sizeof(struct TNode));
                new_node->Data = X;
                new_node->Left = NULL;
                new_node->Right = NULL;
                BST->Left = new_node;
            }
        }else if(X > BST->Data){
            //printf("在根的右边%d  --- %d  
",X,BST->Data);
                if(BST->Right){
                    Insert(BST->Right,X);
                }else{
                    BinTree new_node = (Position)malloc(sizeof(struct TNode));
                    new_node->Data = X;
                    new_node->Left = NULL;
                    new_node->Right = NULL;
                    BST->Right = new_node;
            }
        }
    }
    return BST;
}


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

//删除节点
BinTree Delete( BinTree BST, ElementType X ){
    Position temp;
    if(BST==NULL){
        printf("Not Found
");
        return BST;
    }
    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){
            temp = FindMax(BST->Left);
            BST->Data = temp->Data;
            BST->Left = Delete(BST->Left,BST->Data);
        }else{
            temp = BST;
            if(BST->Left){
                BST = BST->Left;
            }else{
                BST = BST->Right;
            }
            free(temp);
        }
        return 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);
        //printf("%d",X);
        BST = Insert(BST, X);
    }
    printf("Preorder:"); PreorderTraversal(BST); printf("
");
    printf("Inorder:"); InorderTraversal(BST); printf("
");
    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
", X);
        else {
            printf("%d is found
", Tmp->Data);
            if (Tmp==MinP) printf("%d is the smallest key
", Tmp->Data);
            if (Tmp==MaxP) printf("%d is the largest key
", Tmp->Data);
        }
    }
    scanf("%d", &N);
    for( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Delete(BST, X);
    }
    printf("Inorder:"); InorderTraversal(BST); printf("
");
    return 0;
}