实现一棵二叉搜索树

 函数接口

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

描述

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

测试用例

输入

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

代码

#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;
}
BinTree Insert( BinTree BST, ElementType X )
{
	if(!BST)//到达了叶子节点 
	{
		BST=(BinTree)malloc(sizeof(struct TNode));
		BST->Data=X;
		BST->Left=NULL;
		BST->Right=NULL;
	} 
	else
	{
		if(X<BST->Data)//小于根节点的值要放入左子树
			BST->Left=Insert(BST->Left,X);//由于插入函数返回的根节点所以这里我们需要接收一下 
		if(X>BST->Data)//小于根节点的值要放入左子树
			BST->Right=Insert(BST->Right,X);
	}
	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;
} 

Position Find( BinTree BST, ElementType X )//查找指定元素在树中的位置
{
	while(BST)//只要存在就一直往下搜
	{
		if(X<BST->Data)//在左子树上
			BST=BST->Left;
		else if(X>BST->Data)
			BST=BST->Right;
		else 
			break;//找到了恰好等于的节点	
	} 
	return BST;
}

BinTree Delete( BinTree BST, ElementType X )//删除指定元素的节点 
{
	BinTree t;
	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)//删除的节点有左右节点 
			{
				t=FindMin(BST->Right);//从右子树中找出最小的节点用来替代当前节点
				BST->Data=t->Data;//替换成功
				BST->Right=Delete(BST->Right,BST->Data);//删除右子树的最小节点 
			}
			else//有左子树或者有右子树
			{
				t=BST;//储存当前节点 
				if(!BST->Left)//只有右子树，此时只需要用右子树来替换当前节点即可
					BST=BST->Right;
				else 
					BST=BST->Left;
				free(t);//删除节点 
			 } 
		 } 
	}
	return BST;
}


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