数据结构之二叉排序树（基于指针实现基本操作）

定义：

       二叉排序树（Binary Sort Tree）又称二叉查找树，亦称二叉搜索树。 它或者是一棵空树；或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树；

算法实现：

       由于使用C++的模板，声明和定义都在头文件中实现。

#ifndef BINARYSEARCHTREE
#define BINARYSEARCHTREE
namespace BinarySearchTree
{
	template<typename Element>
	class TreeNode
	{
	public:
		Element data;
		TreeNode<Element> *lchild;
		TreeNode<Element> *rchild;
		TreeNode(Element data):data(data),
			lchild(NULL),rchild(NULL){};
		~TreeNode()
		{
			lchild = NULL;
			rchild = NULL;
		};
	};
	template<typename Element>
	class SearchTree
	{
	private:
		TreeNode<Element> *root;
		int NodeNum;	
	public:
		SearchTree(){root = NULL;NodeNum=0;};
		~SearchTree(){DestroyTree();};
		bool TreeIsEmpty();
		int TreeNodeNum(){return NodeNum;};
		bool InsertTreeNode(Element data);
		void InorderTravelTree();
		void SearchNode(Element data);
		bool RemoveTreeNode(Element data);
		Element MaxValueOfTree();
		Element MinValueOfTree();
		int DepthOfTree();
		void DestroyTree();	

		void InsertNode(TreeNode<Element> **t,TreeNode<Element> *node);
		void Inorder(TreeNode<Element> *t);
		TreeNode<Element>* Search(TreeNode<Element>* t, Element data, TreeNode<Element>**pre);
		void DestroyTree(TreeNode<Element>* t);
		int DepthOfTree(TreeNode<Element>* t);
	};


template <typename Element>//判断树是否为空
bool SearchTree<Element>::TreeIsEmpty()
{
	return root == NULL;
}
template <typename Element>//在二叉排序树中插入节点
void SearchTree<Element>::InsertNode(TreeNode<Element> **t,TreeNode<Element> *node)
{
	if(node == NULL)
		return;
	if(*t==NULL)    //新插入的节点总为叶子节点
		*t = node;
	else
	{
		if(node->data<(*t)->data)
			InsertNode(&((*t)->lchild),node);
		else
			InsertNode(&((*t)->rchild),node);
	}
}
template <typename Element>
bool SearchTree<Element>::InsertTreeNode(Element data)
{
	TreeNode<Element> *node = new TreeNode<Element>(data);
	if(node==NULL)
		return false;
	NodeNum++;
	InsertNode(&root,node);
	return true;
}
template <typename Element>//中序遍历二叉排序树，从小到大输出节点值
void SearchTree<Element>::Inorder(TreeNode<Element> *t)
{
	if(t!=NULL)
	{
		Inorder(t->lchild);
		cout<<t->data<<" ";
		Inorder(t->rchild);
	}
}
template <typename Element>
void SearchTree<Element>::InorderTravelTree()
{
	Inorder(root);
	cout<<endl;
}
template <typename Element>//搜索二叉排序树，返回对应的节点，并取得节点的双亲节点
TreeNode<Element>* SearchTree<Element>::Search(TreeNode<Element>* t, Element data, TreeNode<Element>**pre)
{
	if(pre != NULL)
		*pre = t;
	while(t!=NULL)
	{
		if(t->data == data)
			return t;
		else if(t->data > data)
		{
			if(pre != NULL)
				*pre = t;
			t = t->lchild;
		}
		else
		{
			if(pre != NULL)
				*pre = t;
			t = t->rchild;
		}
	}
	if(pre != NULL)
		*pre = NULL;
	return NULL;
}
template <typename Element>
void SearchTree<Element>::SearchNode(Element data)
{
	TreeNode<Element> *pre;
	TreeNode<Element> *node;
	cout<<"================"<<endl;
	if(node=Search(root,data,&pre))
	{
		if(pre!=node)
			cout<<"The parent of "<<data<<" is: "<<pre->data<<endl;
		else
			cout<<data<<" is root node"<<endl;
		if(node->lchild!=NULL)
			cout<<"The left child of "<<data<<" is: "<<node->lchild->data<<endl;
		else
			cout<<"The left child of "<<data<<" is: NULL"<<endl;
		if(node->rchild!=NULL)
			cout<<"The right child of "<<data<<" is: "<<node->rchild->data<<endl;
		else
			cout<<"The right child of "<<data<<" is: NULL"<<endl;
	}
	else
		cout<<data<<" isn't in the tree"<<endl;
	cout<<"================"<<endl;
}
//删除给定值的节点，步骤：
//1、查找到给定值的节点
//2、用节点的右孩子代替原来的节点
//3、将节点的左孩子插到节点的右孩子
//4、释放节点
template <typename Element>
bool SearchTree<Element>::RemoveTreeNode(Element data)
{
	TreeNode<Element>* pre;
	TreeNode<Element>* node;
	node = Search(root,data,&pre);
	if(node == NULL)
		return false;
	if(pre->lchild == node)//删除的是非根节点
	{
		pre->lchild = node->rchild;
		InsertNode(&(pre->lchild),node->lchild);
	}
	else if(pre->rchild == node)//删除的是非根节点
	{
		pre->rchild = node->rchild;
		InsertNode(&(pre->rchild),node->lchild);
	}
	else if(pre == node)//如果删除的是根节点，要改变根节点的指向
	{
		root = node->rchild;
		InsertNode(&root,node->lchild);
	}
	NodeNum--;
	delete node;
	return true;
}
template <typename Element>//返回树中最大值
Element SearchTree<Element>::MaxValueOfTree()
{
	if(root==NULL)
		return -1;
	TreeNode<Element> *node = root;
	while(node->rchild!=NULL)
		node = node->rchild;
	return node->data;
}
template <typename Element>//返回树中最小值
Element SearchTree<Element>::MinValueOfTree()
{
	if(root==NULL)
		return -1;
	TreeNode<Element> *node = root;
	while(node->lchild!=NULL)
		node = node->lchild;
	return node->data;
}
template <typename Element>//销毁树
void SearchTree<Element>::DestroyTree(TreeNode<Element>*t)
{
	if(t!=NULL)
	{
		DestroyTree(t->lchild);
		DestroyTree(t->rchild);
		delete t;
	}
}
template <typename Element>
void SearchTree<Element>::DestroyTree()
{
	DestroyTree(root);
	root=NULL;
	NodeNum = 0;
}
template <typename Element>//返回树的深度
int SearchTree<Element>::DepthOfTree(TreeNode<Element>* t)
{
	if(t==NULL)
		return 0;
	int lh = DepthOfTree(t->lchild);
	int rh = DepthOfTree(t->rchild);
	return 1+(lh>rh?lh:rh);

}
template <typename Element>
int SearchTree<Element>::DepthOfTree()
{
	return DepthOfTree(root);
}
}
#endif