二叉搜索树的操作集

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

本题要求实现给定二叉搜索树的5种常用操作。

函数接口定义：

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 );

其中BinTree结构定义如下：

typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

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

裁判测试程序样例：

#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;
}
/* 你的代码将被嵌在这里 */

输入样例：

10
5 8 6 2 4 1 0 10 9 7
5
6 3 10 0 5
5
5 7 0 10 3

输出样例：

Preorder: 5 2 1 0 4 8 6 7 10 9
6 is found
3 is not found
10 is found
10 is the largest key
0 is found
0 is the smallest key
5 is found
Not Found
Inorder: 1 2 4 6 8 9

 

 

 

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 
  4 typedef int ElementType;
  5 typedef struct TNode *Position;
  6 typedef Position BinTree;
  7 struct TNode{
  8     ElementType Data;
  9     BinTree Left;
 10     BinTree Right;
 11 };
 12 
 13 void PreorderTraversal( BinTree BT ); /* 先序遍历，由裁判实现，细节不表 */
 14 void InorderTraversal( BinTree BT );  /* 中序遍历，由裁判实现，细节不表 */
 15 
 16 BinTree Insert( BinTree BST, ElementType X );
 17 BinTree Delete( BinTree BST, ElementType X );
 18 Position Find( BinTree BST, ElementType X );
 19 Position FindMin( BinTree BST );
 20 Position FindMax( BinTree BST );
 21 
 22 int main()
 23 {
 24     BinTree BST, MinP, MaxP, Tmp;
 25     ElementType X;
 26     int N, i;
 27 
 28     BST = NULL;
 29     scanf("%d", &N);
 30     for ( i=0; i<N; i++ ) {
 31         scanf("%d", &X);
 32         BST = Insert(BST, X);
 33     }
 34     printf("Preorder:"); PreorderTraversal(BST); printf("\n");
 35     MinP = FindMin(BST);
 36     MaxP = FindMax(BST);
 37     scanf("%d", &N);
 38     for( i=0; i<N; i++ ) {
 39         scanf("%d", &X);
 40         Tmp = Find(BST, X);
 41         if (Tmp == NULL) printf("%d is not found\n", X);
 42         else {
 43             printf("%d is found\n", Tmp->Data);
 44             if (Tmp==MinP) printf("%d is the smallest key\n", Tmp->Data);
 45             if (Tmp==MaxP) printf("%d is the largest key\n", Tmp->Data);
 46         }
 47     }
 48     scanf("%d", &N);
 49     for( i=0; i<N; i++ ) {
 50         scanf("%d", &X);
 51         BST = Delete(BST, X);
 52     }
 53     printf("Inorder:"); InorderTraversal(BST); printf("\n");
 54 
 55     return 0;
 56 }
 57 /* 你的代码将被嵌在这里 */
 58 BinTree Insert(BinTree BST, ElementType X){
 59     if(BST == NULL){
 60         BST = (BinTree)malloc(sizeof(struct TNode));
 61         if(BST == NULL) return NULL;
 62         BST->Left = BST->Right = NULL;
 63         BST->Data = X;
 64     }else{
 65         if(BST->Data > X){
 66             BST->Left = Insert(BST->Left, X);
 67         }
 68         else BST->Right = Insert(BST->Right, X);
 69     }
 70     return BST;
 71 }
 72 BinTree Delete(BinTree BST, ElementType X){
 73     if(BST != NULL){
 74         if(BST->Data > X){
 75             BST->Left = Delete(BST->Left, X);
 76         }else if(BST->Data < X){
 77             BST->Right = Delete(BST->Right, X);
 78         }
 79         else{
 80             if(BST->Left && BST->Right){
 81                 BinTree p = FindMin(BST->Right);
 82                 BST->Data = p->Data;
 83                 BST->Right = Delete(BST->Right, BST->Data);
 84             }else{
 85                 BinTree p = BST;
 86                 if(BST->Right){
 87                     BST = BST->Right;
 88                 }else if(BST->Left){
 89                     BST = BST->Left;
 90                 }else{
 91                     BST = NULL;
 92                 }
 93                 free(p);
 94             }
 95             return BST;
 96         }
 97     }
 98     else printf("Not Found\n");
 99     return BST;        
100 }
101 Position Find(BinTree BST, ElementType X){
102     if(BST == NULL || BST->Data == X){
103         return BST;
104     }
105     else if(BST->Data > X){
106         return Find(BST->Left, X);
107     }else{
108         return Find(BST->Right, X);
109     }
110 }
111 
112 Position FindMin(BinTree BST){
113     if(BST == NULL){
114         return NULL;
115     }
116     Position Min = BST;
117     Position Left = FindMin(BST->Left );
118     Position Right = FindMin(BST->Right );
119     if(Left && Left -> Data < Min -> Data){
120         Min = Left;
121     }
122     if(Right && Right->Data < Min ->Data) Min = Right;
123     return Min;
124 }    
125 
126 Position FindMax(BinTree BST){
127     if(BST == NULL) return NULL;
128     Position Max = BST;
129     Position Left = FindMax(BST->Left );
130     Position Right = FindMax(BST->Right );
131     if(Left && Left->Data > Max->Data) Max = Left;
132     if(Right && Right->Data > Max->Data )Max = Right;
133     return Max;
134 }