BST(二叉搜索树)代码实现

#include<iostream>
#include<cstdio>
#include<cstdlib>
#define SIZE(a) ((sizeof(a)) / sizeof(a[0])) 
using namespace std;
static int arr[] = { 1,5,4,3,2,6 };
typedef int Type;
typedef struct BST_Node {
	Type key;
	struct BST_Node *lchild;
	struct BST_Node *rchild;
	struct BST_Node *parent;

}Node, *BSTree;
void PreOrderTraverse(BSTree);//遍历 
void InOrderTraverse(BSTree);
void PostOrderTraverse(BSTree);//删除打印 
void bst_Destory(BSTree x);
void bst_Print(BSTree, Type, int);
BSTree bst_Search(BSTree, Type);//查找 
BSTree bst_Search_iterative(BSTree, Type);
BSTree bst_minimum(BSTree);
BSTree bst_maximum(BSTree);//前驱后继 
BSTree bst_pred(BSTree x);
BSTree bst_succ(BSTree x);
BSTree bst_Delete(BSTree, Type);//修改 
BSTree bst_Insert(BSTree, Type);

void PreOrderTraverse(BSTree T) {
	if (T) {
		cout << T->key;
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}

void InOrderTraverse(BSTree T) {
	if (T) {
		InOrderTraverse(T->lchild);
		cout << T->key;
		InOrderTraverse(T->rchild);
	}
}

void PostOrderTraverse(BSTree T) {
	if (T) {
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		cout << T->key;
	}
}
//Search by recursion
BSTree bst_Search(BSTree T, Type key) {
	if (T == NULL || T->key == key)return T;

	if (key < T->key)
		return bst_Search(T->lchild, key);
	else
		return bst_Search(T->rchild, key);
}
BSTree bst_Search_iterative(BSTree T, Type key) {
	while (T && T->key != key) {
		if (key < T->key) T = T->lchild;
		else T = T->rchild;
	}
	return T;
}

BSTree bst_minimum(BSTree T) {
	if (!T) return NULL;
	while (T->lchild != NULL) T = T->lchild;
	return T;
}

BSTree bst_maximum(BSTree T) {
	if (!T) return NULL;
	while (T->rchild != NULL) T = T->rchild;
	return T;
}

// 结点的后继结点等价于寻找BST中key大于该结点的最小结点
BSTree bst_succ(BSTree T) {
	// 若x存在右孩子，则x的后继结点为以其右孩子为根的子树的最小结点
	if (T->rchild)return bst_minimum(T->rchild);
	/*若节点没有右孩子 则有两种可能
	1:T为其父节点的左孩子，则其后继节点为其父亲
	2：T为其父节点的右孩子，则寻找其父节点的父节点*/
	BSTree P = T->parent;//
	while (P && (T == P->rchild)) {//2
		T = P;
		P = P->parent;
	}
	return P;
}
//节点的前驱和后继恰好相反
BSTree bst_pred(BSTree T) {
	if (T->lchild) return bst_maximum(T->lchild);
	BSTree P = T->parent;
	while ((P) && (T == P->lchild)) {
		T = P;
		P = P->parent;
	}
	return P;
}
static BSTree Create_BSTreeNode(Type key, BSTree parent, BSTree lchild, BSTree rchild) {

	BSTree t;
	if ((t = (Node *)malloc(sizeof(Node))) == NULL) return NULL;
	t->key = key;
	t->lchild = lchild;
	t->rchild = rchild;
	t->parent = parent;
	return t;
}
static BSTree Insert(BSTree T, BSTree  NODE) {
	BSTree X = NULL;
	BSTree Y = T;
	while (X) {
		Y = X;
		if (NODE->key < X->key)
			X = X->lchild;
		else
			X = X->rchild;
	}
	NODE->parent = Y;
	if (Y == NULL) T = NODE;
	else if (NODE->key < Y->key)
		Y->lchild = NODE;
	else Y->rchild = NODE;
	return T;
}

BSTree bst_Insert(BSTree T, Type key) {
	BSTree NODE;
	if ((NODE = Create_BSTreeNode(key, NULL, NULL, NULL)) == NULL) return T;
	return Insert(T, NODE);
}

static BSTree Delete(BSTree T, BSTree NODE) {
	BSTree X = NULL;
	BSTree Y = NULL;
	if ((NODE->lchild == NULL) || (NODE->rchild == NULL)) Y = NODE;
	else Y = bst_succ(NODE);

	if (Y->lchild) X = Y->rchild;
	else X = Y->rchild;

	if (X) X->parent = Y->parent;

	if (!Y->parent) T = X;
	else if (Y == Y->parent->lchild) Y->parent->lchild = X;
	else Y->parent->rchild = X;

	if (Y != NODE) NODE->key = Y->key;
	if (Y) free(Y);

	return T;
}

BSTree bst_Delete(BSTree T, Type key) {
	BSTree NODE;
	if ((NODE = bst_Search(T, key)) != NULL) T = Delete(T, NODE);
	return T;
}

void bst_Destory(BSTree T) {
	if (!T)return;

	if (T->lchild) bst_Destory(T->lchild);
	if (T->rchild) bst_Destory(T->rchild);

	free(T);
}
void bst_Print(BSTree T, Type key, int Direction) {
	if (T) {
		if (Direction == 0) cout << "root is " << T->key;
		else cout << T->key << "is" << key << "'s" << Direction << "child";
		bst_Print(T->lchild, T->key, -1);
		bst_Print(T->rchild, T->key, 1);
	}
}

int main() {
	int i, len;
	BSTree root = NULL;
	cout << "Binary Search Tree";
	len = SIZE(arr);

	root = bst_Insert(root, 1);
	cout << 1;
	cout << "\n\nPreOrderTraverse: ";
	PreOrderTraverse(root);

	cout << "\nInOrderTraverse: ";
	InOrderTraverse(root);

	cout << "\nPostOrderTraverse: ";
	PostOrderTraverse(root);

	cout << "\nmax value is " << bst_maximum((root)) << endl;
	cout << "\nmin value is " << bst_minimum((root)) << endl;
	cout << "\nTraverse BST \n";
	bst_Print(root, root->key, 0);
	cout << "\nDelete root  " << arr[3];
	root = bst_Delete(root, arr[3]);

	cout << "\nInOrderTraverse ";
	InOrderTraverse(root);
	bst_Destory(root);
	system("pause");
	return 0;
}