二叉搜索树(c++)

该版本翻译了算法导论中的伪代码。 水平有限，不足之处望指出。

#ifndef BST_H
#define BST_H
using namespace std;
template<class T>
struct BstNode{
	BstNode(T k = 12, BstNode<T>* lt = NULL, BstNode<T> *rt = NULL, BstNode<T> *pt = NULL) :key(k), left(lt), right(rt), parent(pt){}
	T key;
	BstNode<T> *left;
	BstNode<T> *right;
	BstNode<T> *parent;


};//二叉树 结点类

template<class T>
class BsTree{
public:
	BsTree(){  }
	~BsTree(){ }
	void Destroy(BstNode<T>*&Node); //destroy a tree.
	void InOrder(BstNode<T> *&Node);//output the datas,from small to big;
	void CreateBst(BstNode<T>*&Tree);
	bool Search(BstNode<T> *&Node, T x);//search the exact data;
	BstNode<T> *Locate(BstNode<T>*Node, T x);//find address;
	BstNode<T> *MaxTree(BstNode<T> * &Node); //max,return *p;
	T OutputMax(BstNode<T> * Node);//max ,return value;
	BstNode<T> *MinTree(BstNode<T> * &Node);//min, return *p;
	T OutputMin(BstNode<T> * Node);//min return value;
	BstNode<T> *Successor(BstNode<T> *Node);//search the seuccessor
	bool Insert(BstNode<T>*&Node, T m);//insert value ;
	void  TransPlant(BstNode<T>*&Node, BstNode<T>*&x, BstNode<T>*&y);//定位1
	bool Delete(BstNode<T>*Node, BstNode<T>*&del);
	int Seq_Search(int *a, int n, int key);//顺序查找
	int Dichotomy(int *b, int n, int key);//二分查找
private:
	BstNode<T>*root;


};
/*删除BST*/

template<class T>
void BsTree<T>::Destroy(BstNode<T>*&Node){
	if (Node != NULL){
		Destroy(Node->left);
		Destroy(Node->right);
		delete Node;
	}
}
/*删除BST*/
template<class T>  //中序输出的实现 
void BsTree<T>::InOrder(BstNode<T> *&Node){
	if (Node == NULL) return;
	InOrder(Node->left);
	cout << " <" << Node->key << "> ";
	InOrder(Node->right);

}
template<class T> //查找指定的x,存在则True
bool BsTree<T>::Search(BstNode<T> *&Node, T x){
	if (Node == NULL) return NULL;
	if (Node->key == x)
		return true;
	if (Node->key > x)
		return Search(Node->left, x);
	else return Search(Node->right, x);
}
template<class T>
BstNode<T>*BsTree<T>::Locate(BstNode<T>*Node, T x){ //
	if (Node == NULL) return NULL;
	if (Node->key == x)
		return Node;
	if (Node->key > x)
		return Locate(Node->left, x);
	else return Locate(Node->right, x);
}
template<class T>
BstNode<T> *BsTree<T>::MaxTree(BstNode<T> * &Node){//返回地址，供其他函数调用
	while (Node->right != NULL)
		Node = Node->right;
	return Node;
}
template<class T>
T BsTree<T>::OutputMax(BstNode<T> * Node){ //返回值
	while (Node->right != NULL)
		Node = Node->right;
	return Node->key;
}
template<class T>
BstNode<T> *BsTree<T>::MinTree(BstNode<T> * &Node){//返回地址，供其他函数调用
	if (Node != NULL && Node->left != NULL)
		Node = Node->left;
	return Node;
}
template<class T>
T BsTree<T>::OutputMin(BstNode<T> *Node){//返回值
	while (Node->left != NULL)
		Node = Node->left;
	return Node->key;
}
template<class T>
BstNode<T> *BsTree<T>::Successor(BstNode<T> *Node){
	if (Node->right != NULL)
		return MinTree(Node->right);//如果结点的右子树非空，就返回右子树的分支中最小的关键值
	BstNode<T>*p = Node->parent;
	while (p != NULL && Node == p->right)
	{
		Node = p;
		p = p->parent;
	}

	return p;
}

template<class T>
bool BsTree<T>::Insert(BstNode<T>*&Node, T m){ //Node为根节点 算法导论中的做法
	BstNode<T> *y = NULL;
	BstNode<T> *x = Node;
	BstNode<T> *temp = NULL;
	while (x != NULL){
		y = x;
		if (m < x->key){
			x = x->left;
			//x->parent = y;
		}
		else{ x = x->right; } // x->parent = y; }
	}
	if (y == NULL)
		Node = new BstNode<T>(m);
	else if (m < y->key) {
		y->left = new BstNode<T>(m);
		y->left->parent = y;
	}
	else {
		y->right = new BstNode<T>(m);
		y->right->parent = y;
	}
	return true;
}
template<class T>
void BsTree<T>::TransPlant(BstNode<T>*&Node, BstNode<T>*&x, BstNode<T>*&y){//用y替换结点x,并且更新Parent. 
	// if (x->parent == NULL)
	//    Node.root = y;

	if (x == x->parent->left){
		x->parent->left = y;
		// y->parent = x->parent;
		//delete x;
	}
	else {
		// y->parent = x->parent;
		x->parent->right = y;
		//delete x;
	}
	// if (y == NULL);
	// y->parent = x->parent;
}
template<class T>
bool BsTree<T>::Delete(BstNode<T>*Node, BstNode<T>*&del){
	BstNode<T>*p = NULL;
	if (del->left == NULL &&del->right == NULL) //删除叶结点
	{
		if (del == del->parent->left)  del->parent->left = NULL;
		else del->parent->right = NULL;
		delete del;
		return true;
	}
	if (del->left == NULL &&del->right != NULL)//左子树空
	{
		TransPlant(Node, del, del->right);
		return true;
	}
	else if (del->right == NULL && del->left != NULL)//右子树空
	{
		TransPlant(Node, del, del->left);
		return true;
	}
	else p = MinTree(del->right); //左右都不空
	if (p != NULL &&p->parent == del)
	{
		TransPlant(Node, p, p->right);
		p->right = del->right;
		p->right->parent = p;
		return true;
	}
	else
	{
		TransPlant(Node, del, p);
		p->left = del->left;

	}
	return true;
}
template<class T >
int BsTree<T>::Seq_Search(int *a, int n, int key)
{
	for (int i = 0; i < n; i++)
	{
		if (a[i] == key)
			return i;
	}
	return 0;
}

template<class T>
int BsTree<T>::Dichotomy(int *b, int n, int key){
	int start = 0, mid = 0, end = n;

	while (start <= end){
		mid = (start + end) / 2;
		if (b[mid] < key)
			start = mid + 1;
		else if (b[mid] > key)
			end = mid - 1;
		else return mid;
	}
	return -1;
}


<pre name="code" class="cpp">#include<iostream>
#include"BST.h"
#include<stdlib.h>
#include<ctime>
#include<time.h>
using namespace std;


int main()
{

	BstNode<int>*Node = new BstNode<int>;
	BsTree<int> Tree;

	/****************//*制造随机数，插入树中*//****************/
	srand((unsigned)time(NULL));
	int A[100000];
	for (int i = 0; i != 100000; i++)
	{
		A[i] = rand();
		Tree.Insert(Node, A[i]);
	}
	/****************//*制造随机数，插入树中 *//****************/


	/****************//* 制造固定的数组，演示删除*//****************/
	/*int B[13] = { 5, 25, 2, 9, 18, 30, 14, 20,13,16 ,19,21};
	for (int i = 0; i != 12; i++)
	Tree.Insert(Node,B[i]);*/
	/****************//* 制造固定的数组，演示删除*//****************/


	/*************/ /* 在二叉搜索树中 输出最小/大的值*/  /******************/
	/*cout << "The minimal key is:" <<"<"<< Tree.OutputMin(Node)<<">" << endl;
	cout << "The max key is:" << "<"<<Tree.OutputMax(Node) <<">" <<endl;*/

	/*************/ /*在二叉搜索树中 输出最小/大的值*/  /******************/


	/****************/ /*查找一个数 是否存在在二叉搜索树中*/  /*********************/
	/*int Num_exist = 0;
	cout << "Input the key value that you want to search." << endl;
	cin >> Num_exist;
	if (Tree.Search(Node, Num_exist))
	cout << Num_exist <<" "<< "exist." << endl;
	else cout << Num_exist << " isn't exist. " << endl;*/
	/****************/ /*查找一个数 是否存在在二叉搜索树中*/  /*********************/


	/****************/ /*删除*/  /*********************/

	/*	BstNode<int>*Node_2 = Tree.Locate(Node,18); //创建一个新的结点 ,赋予他原结点Key=18的地址
	Tree.Delete(Node, Node_2);
	cout<<"After Delete 18 "<<endl;
	Tree.InOrder(Node); //中序输出（按从小到大的顺序输出) ; 
	/****************/ /*删除*/  /*********************/

	/***************/ // BST查找//***************/
	clock_t start_time_1 = clock();
	if (Tree.Locate(Node, 2))
		cout << "BST search succeed!" << endl;
	clock_t end_time_1 = clock();
	cout << "Binary Serach Tree search-->Running time is: " << static_cast<double>(end_time_1 - start_time_1) / CLOCKS_PER_SEC * 1000 << "ms" << endl;

	/**************BST查找//***************/

	return 0;
}

#endif