bstree.h

二叉排序树的几种操作 包括：建立二叉排序树

#include<iostream.h>
#include<stdlib.h>

typedef struct BSTreeNode
{
	int data;
	struct BSTreeNode *leftChild;
	struct BSTreeNode *rightChild;
}BSTreeNode;

class BSTree
{
	public:
		BSTree(void);
		void Display(void);//显示这个树
		void Insert(int data);//在树中插入一个值
		Delete(int data);//在树中删除一个值
		BSTreeNode* Find(int data);//在树中查找一个值
		~BSTree();
	private:
		BSTreeNode* buildTree(BSTreeNode* head,int number);//建立一个树
		BSTreeNode* search(BSTreeNode* head ,int data);//查找
		BSTreeNode* BSTree::searchParent(BSTreeNode* head,BSTreeNode* p);//查找出p的父亲节点的指针
		BSTreeNode* BSTree::searchMinRight(BSTreeNode* head);//找到右子树中最小的节点
		void showTree(BSTreeNode* head);//显示
		void destroyTree(BSTreeNode* head);//删除
		BSTreeNode *head;
};

//建立一个二叉排序树
BSTree::BSTree()
{
   cout<<"Build the BSTree  (end with -1): "<<endl;
   head=NULL;
   int number;
   cin>>number;
   while(number!=-1)
   {
		head=buildTree(head,number);
		cin>>number;  
   }
}

//建立
BSTreeNode* BSTree::buildTree(BSTreeNode* head,int number)
{
	BSTreeNode *p;    
	p=new BSTreeNode;
    p->data=number;
	p->leftChild=p->rightChild=NULL;
	if(head==NULL)
	{
		return p;
	}
	else
	{
       if(p->data<head->data)
		   head->leftChild=buildTree(head->leftChild,number);
	   else
		   head->rightChild=buildTree(head->rightChild,number);
	   return head;
	}
}

//插入一个结点
void BSTree::Insert(int data)
{
	head=buildTree(head,data);
}

//查找一个结点
BSTreeNode* BSTree::Find(int data)
{
	return search(head,data);
}

BSTreeNode* BSTree::search(BSTreeNode* head ,int data)
{  
	if(head==NULL)
		return NULL;
	if(head->data==data)
		return head;
	else 
	{
		if(data<head->data)
			return search(head->leftChild,data);
		else
			return search(head->rightChild,data);
	}
}

//删除一个结点
BSTree::Delete(int data)
{
	BSTreeNode *p;
	p=NULL;
    p=search(head,data);
	if(p==NULL)
	{
		cout<<"Not find."<<endl;
	}
	else
	{
    if(p==head)
	{
		head=NULL;
	}
	else
	{ 
		BSTreeNode* parent;
		parent=searchParent(head,p);
		if(p->leftChild==NULL&&p->rightChild==NULL)//叶子节点
		{
			if(parent->leftChild==p)
			{
				parent->leftChild=NULL;
			}
			else
			{
				parent->rightChild=NULL;

			}
		}
        else//非叶子节点
		{
           if(p->rightChild==NULL)//该节点没有右孩子
			{
				if(parent->leftChild==p)
				{
					parent->leftChild=p->leftChild;
				}
				 else
				{
					 parent->rightChild=p->leftChild;
				}
			}
			else//该点有左右孩子
			{
				BSTreeNode *rightMinSon,* secondParent;//secondParent为右子树中的最小节点的父亲
				rightMinSon=searchMinRight(p->rightChild);
				secondParent=searchParent(p->rightChild,rightMinSon);
				secondParent->leftChild=rightMinSon->rightChild;
				if(p->rightChild==rightMinSon)//右子树中的最小节点的父亲为p
				{
					p->rightChild=rightMinSon->rightChild;
				}
				p->data=rightMinSon->data;
			} 
		}
	}
	}
}

BSTreeNode* BSTree::searchParent(BSTreeNode* head,BSTreeNode* p)
{
	if(head->leftChild==p||head->rightChild==p||head==p||head==NULL)
		return head;
    else
	{
		if(p->data<head->data)
			return searchParent(head->leftChild,p);
		else
			return searchParent(head->rightChild,p);
	}
}

BSTreeNode* BSTree::searchMinRight(BSTreeNode* head)//找到右子树中最小的节点
{
	if(head->leftChild==NULL||head==NULL)
	{
		return head;
	}
	else
	{
		return searchMinRight(head->leftChild);
	}
}

//显示二叉排序树
void BSTree::Display(void)
{
	showTree(head);
	cout<<endl;
}

void BSTree::showTree(BSTreeNode* head)
{
	if(head!=NULL)
	{
		showTree(head->leftChild);
		cout<<head->data<<' ';
		showTree(head->rightChild);
	}
}

//删除整棵二叉排序树
BSTree::~BSTree()
{
	cout<<"Deleted the Whole Tree!"<<endl;
	destroyTree(head);
}

void BSTree::destroyTree(BSTreeNode* head)
{
	if(head!=NULL)
	{
		destroyTree(head->leftChild);
		destroyTree(head->rightChild);
		delete head;
	}

}

//showmessage
void print()
{
	cout<<endl
	<<"1.Display "
    <<"2.Insert "
	<<"3.Find "
	<<"4.Delete"<<endl;
}

/*
template<class Type> class BSBSTreeNode<Type>::public BinBSTreeNode<Type>{
//二叉排序树结点类的定义
	friend class BSTree<Type>;
	public:
		BSBSTreeNode():leftChild(NULL),rightChild(NULL){}//构造函数
		BSBSTreeNode(const Type d):data(d),leftChild(NULL),rightChild(NULL){}
		//构造函数
		~BSBSTreeNode(){}
		void displayTree(void)
        void showTree(BinBSTreeNode* head);
	protected:
		Type data;
		BSBSTreeNode<Type>* leftChild,* rightChild;
};

template<class Type> class BSTree<Type>::public BinaryTree<Type>
{
	public:
		BSTree()(void);//构造函数
		~BSTree();//析构函数
		BSBSTreeNode<Type>* Find(const Type &k) const
			{return Find(k,root);}//查找
		Type Min();
		Type Max();
		void Insert(const Type &x)
			{Insert(x,root);}
		void Delete(const Type &k)
			{Delete(k,root);}
	private:
		BSBSTreeNode<Type>* root;
		BSBSTreeNode<Type>* Find(const Type &k,BSBSTreeNode<Type>* p)const;
		void Insert(const Type &x,BSBSTreeNode<Type>* &p);
		void Delete(const Type &k,BSBSTreeNode<Type>* &p);
		BSBSTreeNode<Type>* head;
}*/

/*template<class Type>BSBSTreeNode<Type>*BSTree<Type>::          //递归
Find(const Type &k,BSBSTreeNode<Type>*p)const{
	if(p==NULL)
		return NULL;
	else if(k<p->data)
		return Find(k,p->leftChild);
	   else if(k>p->data)
		   return Find(k,p->rightChild);
	      else return p;
}

template<class Type>					非递归
BSBSTreeNode<Type> * BSTree<Type>::
Find(const Type &k,BSBSTreeNode<Type>*p)const{
	BSBSTreeNode<Type>* temp=p;
	if(p!=NULL){
		while(temp!=NULL){
			if(temp->data==k)return temp;
			if(temp->data<k)
				temp=temp->rightChild;
			else temp=temp->leftChild;}
	}
		return temp;
}

template<class Type> void<Type>BSTree<Type>::
Insert(const Type &k,BSBSTreeNode<Type>* &p){
	if(p==NULL) 
		p=new BSBSTreeNode<Type>(k);
	else if(k<p->data)
		 Insert(k,p->leftChild);
	else if(k>p->data)
		 Insert(k,p->rightChild);
	else
	{
		cout<<"There has node k"<<end;
		exit(1);
	}
}

template<class Type> void<Type> BSTree<Type>::
Delete(const Type &k,BSBSTreeNode<Type>* &p){
	BSBSTreeNode<Type>* temp;
	if(p!=NULL)
	   if(k<p->data)
		 Delete(k,p->leftChild);
	else if(k>p->data)
		 Delete(k,p->rightChild);
	else if(p->leftChild!=NULL&&p->rightChild!=NULL)
	{
		temp=Min(p->rightChild);
		p->data=temp->data;
		Delete(p->data,temp);
	}
	else
	{
		temp=p;
	    if(p->leftChild==NULL)
			p=p->rightChild;
		else
			p=p->leftChild;
		delete temp;
	}
}

template<class Type>
void<Type>BSTree<Type>::displayTree(void)
{

showTree(Head);
cout<<endl;
}
template<class Type>
void<Type> BSTree<Type>::showTree(BSBSTreeNode* Head)
{

if(Head!=NULL)
{
showTree(Head->left ) ;

    cout<<Head->key<<' ' ;

showTree(Head->right) ;

}

template<class Type>
Type<Type>BSTree<Type>::
Min(BSBSTreeNode<Type>*& p){
	if(p->leftChild!=NULL)
		p=p->leftChild;
	return p->data;
}
template<class Type>
Type<Type>BSTree<Type>::
Max(BSBSTreeNode<Type>*& p){
	if(p->rightChild!=NULL)
		p=p->rightChild;
	return p->data;
}
*/