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

结尾无空行

//查找数据为X的节点位置1 
/*
Position Find( BinTree BST, ElementType X ){	//递归实现 
	if(BST==NULL)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 Find(BinTree BST,ElementType x){
        //如果树是空的 返回NULL
        if(!BST) 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);
        }

    }



//查找数据为X的结点位置2 
/*Position Find( BinTree BST, ElementType X )		//非递归实现 
{
	while(BST){
		if(X>BST->Data)	BST=BST->Right;
		else if(X<BST->Data) BST=BST->Left;
		else return BST;
	}
	return NULL;
}*/

//查找二叉树中数值最小的结点（二叉树的最左面） 
/*Position FindMin(BinTree BST){
	if(BST==NULL)return NULL;		//如果结点为空 直接返回 
	else if(BST->Left==NULL){		//如果结点左边为空 代表此节点就是最左边的结点 
		return BST;					//返回结点指针 
	}else return FindMin(BST->Left);	//否则（左面还有节点 向左边递归查找） 
}*/

//非递归查找最小值的结点位置 
Position FindMin(BinTree BST){
	if(BST!=NULL)		//首先判断树空不空 
	while(BST->Left)BST=BST->Left;		//如果左边结点一直存在就一直向左循环，直到到达最左面 
	return BST; 
}


//查找二叉树中数值最大的结点（二叉树的最右面）
/*Position FindMax(BinTree BST){		//原理与FindMin同理 
	if(BST==NULL)return NULL;
	else if(BST->Right==NULL){
		return BST;
	}else FindMax(BST->Right);
} */
Position FindMax(BinTree BST){
       if(BST){
            while(BST->Right){
                BST=BST->Right;
            }
        }
        return BST;
}



BinTree Insert( BinTree BST, ElementType X ){
	if(BST==NULL){		//如果节点位置为空 就创建一个节点并将X放进去 
		BST=(BinTree)malloc(sizeof(struct TNode));
		BST->Data=X;
		BST->Left=NULL;
		BST->Right=NULL;
	}
	else if(X>BST->Data) BST->Right=Insert(BST->Right,X);
	else if(X<BST->Data) BST->Left=Insert(BST->Left,X);
	return BST;

}

//删除：
//1.如果是删除叶子结点 那么就是判断这个节点左右是否都为空 如果是那么就将该结点父亲
//指针的子树设置为NULL
//2.如果删除的是只有一个孩子结点的 那么就将结点A的孩子连接到A的父节点 
//3.如果删除的结点有两个孩子  用左子树的最大值或者右子树的最小值替换
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=FindMin(BST->Right);
            BST->Data=tmp->Data;
            BST->Right=Delete(BST->Right,tmp->Data);
        }
        else {
        tmp=BST;
        if(BST->Left==NULL)
		{
            BST=BST->Right;
        }else if(BST->Right==NULL)
            BST=BST->Left;

        free(tmp);//不要忘记free掉
        }
        }
        }
        return BST;
}