#数据结构与算法学习笔记#PTA8：实现一棵二叉搜索树（C/C++）

2018.3.28

实现一个二叉搜索树，因为是一道函数题，题目之前已经给定了C语言裁判代码，因此直接用C语言实现。

满足下面三个条件的二叉树为二叉搜索树：

1.若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值

2.若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值

3.它的左、右子树也分别为二叉搜索树。

---

主要包括前序、中序、后序遍历和几个操作函数：

1. 函数Insert将X插入二叉搜索树BST并返回结果树的根结点指针；

2. 函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；如果X不在树中，则打印一行Not Found并返回原树的根结点指针；

3. 函数Find在二叉搜索树BST中找到X，返回该结点的指针；如果找不到则返回空指针；

4. 函数FindMin返回二叉搜索树BST中最小元结点的指针；

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

// BinTree.cpp: 定义控制台应用程序的入口点。
// 

#include "stdafx.h"
#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);  //中序遍历
void PostorderTraversal(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");

	system("pause");
	return 0;
}


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

void PostorderTraversal(BinTree BT) {
	if (BT) {
		PostorderTraversal(BT->Left);
		PostorderTraversal(BT->Right);
		printf("%d ", BT->Data);
	}
}


BinTree Insert(BinTree BST, ElementType X) {
	//如果当前树结点为空，生成并返回一个结点的二叉搜索树
	if (!BST) {
		BST = (BinTree)malloc(sizeof(struct TNode));
		BST->Data = X;
		BST->Left = NULL;
		BST->Right = NULL;
	}
	//否则递归插入左右子树，若元素X已经存在，则不满足二叉树的元素互异性，不进行操作
	else {
		if (X < BST->Data) {
			BST->Left = Insert(BST->Left, X);
		}
		else if(X > BST->Data)
		{
			BST->Right = Insert(BST->Right, X);
		}
	}
	return BST;
}


BinTree Delete(BinTree BST, ElementType X) {
	Position Tmp;

	if (!BST)
		printf("Not Found\n");		//若找不到该结点，打印Not Found并返回根节点
	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, BST->Data);
			}
			else {
				//如果被删除结点有一个或没有子结点
				Tmp = BST;
				if (!BST->Left) {
					BST = BST->Right;	//若只有右子结点或无子结点，将结点替换或置NULL
				}
				else {
					BST = BST->Left;	//若只有左子结点，将结点替换或置NULL
				}
				free(Tmp);		//释放空间
			}
		}
	}
	return BST;
}

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)return NULL;
	else if (!BST->Left) {
		return BST;			//返回最左结点
	}
	else {
		return FindMin(BST->Left);	//递归查找左分支
	}
}

Position FindMax(BinTree BST) {
	if (!BST)return NULL;
	while (BST->Right) {
		BST = BST->Right;
	}
	return BST;
}

---

#Coding一小时，Copying一秒钟。留个言点个赞呗，谢谢你#