二叉树

BinTreeNode.h

template<typename Type>class BinaryTree;

template<typename Type>class BinTreeNode{
private:
	BinTreeNode<Type> *m_pleft, *m_pright;
	Type m_data;
public:
	friend class BinaryTree<Type>;
	BinTreeNode():m_pleft(NULL),m_pright(NULL){}
	BinTreeNode(Type item, BinTreeNode<Type> *left=NULL, BinTreeNode<Type> *right=NULL)
		:m_data(item),m_pleft(left),m_pright(right){}

	Type GetData() const;
	BinTreeNode<Type> *GetLeft() const;
	BinTreeNode<Type> *GetRight() const;

	void SetData(const Type data);
	void SetLeft(BinTreeNode<Type> *left);
	void SetRight(BinTreeNode<Type> *right);

	void InOrder();
	void PreOrder();
	void PostOrder();

	int Size();
	int Height();
	BinTreeNode<Type> * Copy(const BinTreeNode<Type> *copy);
	void Destroy(){
		if(this != NULL)
		{
			this->m_pleft->Destroy();
			this->m_pright->Destroy();
			delete this;
		}
	}

	friend bool equal<Type>(const BinTreeNode<Type> *s, const BinTreeNode<Type> *t);
};

BinTreeNode.cpp

template<typename Type> Type BinTreeNode<Type>::GetData() const{
	if(this != NULL)
		return this->m_data;
	return -1;
}

template<typename Type> BinTreeNode<Type>* BinTreeNode<Type>::GetLeft() const{
	if(this != NULL)
		return this->m_pleft;
	return NULL;
}

template<typename Type> BinTreeNode<Type>* BinTreeNode<Type>::GetRight() const{
	if(this != NULL)
		return this->m_pright;
	return NULL;
}

template<typename Type> void BinTreeNode<Type>::SetData(const Type data){
	if(this != NULL)
		this->m_data = data;
}

template<typename Type> void BinTreeNode<Type>::SetLeft(BinTreeNode<Type> *left){
	if(this != NULL)
		this->m_pleft = left;
}

template<typename Type> void BinTreeNode<Type>::SetRight(BinTreeNode<Type> *right){
	if(this != NULL)
		this->m_pright = right;
}

template<typename Type> BinTreeNode<Type>* BinTreeNode<Type>::Copy(const BinTreeNode<Type> *copy){
	if(copy == NULL)
		return NULL;
	BinTreeNode<Type> * temp = new BinTreeNode<Type>(copy->m_data);
	temp->m_pleft = Copy(copy->m_pleft);
	temp->m_pright = Copy(copy->m_pright);
	return temp;
}

template<typename Type> bool equal(const BinTreeNode<Type> *s,const BinTreeNode<Type> *t){
	if(s == NULL && t == NULL)
		return 1;
	if(s && t)
	{
		if(s->m_data != t->m_data)
			return 0;
		if(! equal(s->m_pleft,t->m_pleft))
			return 0;
		if(! equal(s->m_pright, t->m_pright))
			return 0;
		return 1;
	}
	else return 0;
}

template<typename Type> void BinTreeNode<Type>::InOrder(){
	if(this != NULL)
	{
		this->m_pleft->InOrder();
		cout<<this->m_data<<' ';
		this->m_pright->InOrder();
	}
}

template<typename Type> void BinTreeNode<Type>::PreOrder(){
	if(this != NULL)
	{
		cout<<this->m_data<<' ';
		this->m_pleft->PreOrder();
		this->m_pright->PreOrder();
	}
}

template<typename Type> void BinTreeNode<Type>::PostOrder(){
	if(this != NULL)
	{
		this->m_pleft->PostOrder();
		this->m_pright->PostOrder();
		cout<<this->m_data<<' ';
	}
}

template<typename Type> int BinTreeNode<Type>::Size(){
	if(this == NULL)
		return 0;
	return 1 + this->m_pleft->Size() + this->m_pright->Size();
}

template<typename Type> int BinTreeNode<Type>::Height(){
	if(this == NULL)
		return 0;
	int a = this->m_pleft->Height() + 1;
	int b = this->m_pright->Height() + 1;
	return a>b ? a : b;
}

BinaryTree.h

#include "BinTreeNode.h"

template<typename Type> class BinaryTree{
private:
	Type m_stop;
	BinTreeNode<Type> *m_proot;
	BinTreeNode<Type> *GetParent(BinTreeNode<Type> *start, BinTreeNode<Type> *current);
	void Print(BinTreeNode<Type> *start, int n=0);
public:
	BinaryTree():m_proot(NULL){}
	BinaryTree(const Type stop):m_stop(stop),m_proot(NULL){}
	BinaryTree(BinaryTree<Type>& copy);
	virtual ~BinaryTree(){m_proot->Destroy();}

	virtual bool IsEmpty(){return m_proot==NULL;}

	virtual BinTreeNode<Type> *GetLeft(BinTreeNode<Type> *current);
	virtual BinTreeNode<Type> *GetRight(BinTreeNode<Type> *current);
	virtual BinTreeNode<Type> *GetParent(BinTreeNode<Type> *current);
	const BinTreeNode<Type> *GetRoot() const;

	virtual bool Insert(const Type item);
	virtual BinTreeNode<Type> *Find(const Type item) const;

	void InOrder();
	void PreOrder();
	void PostOrder();

	int Size();
	int Height();

	BinaryTree<Type>& operator=(const BinaryTree<Type> copy);

	friend bool operator==<Type>(const BinaryTree<Type> s, const BinaryTree<Type> t);
	friend ostream& operator<< <Type>(ostream&, BinaryTree<Type>&);
	friend istream& operator<< <Type>(istream&, BinaryTree<Type>&);
};

BinaryTree.cpp

template<typename Type> BinaryTree<Type>::BinaryTree(BinaryTree<Type>& copy){
	if(copy.m_proot != NULL)
		this->m_stop = copy.m_stop;
	m_proot = this->m_proot->Copy(copy.m_proot);
}

template<typename Type> BinTreeNode<Type>* BinaryTree<Type>::GetLeft(BinTreeNode<Type> *current){
	if(current == NULL)
		return NULL;
	return current->m_pleft;
}

template<typename Type> BinTreeNode<Type>* BinaryTree<Type>::GetRight(BinTreeNode<Type> *current){
	if(current == NULL)
		return NULL;
	return current->m_pright;
}

template<typename Type> const BinTreeNode<Type>* BinaryTree<Type>::GetRoot() const{
	return this->m_proot;
}

template<typename Type> BinTreeNode<Type>* BinaryTree<Type>::GetParent(BinTreeNode<Type> *start, BinTreeNode<Type> *current){
	if(start == NULL)
		return NULL;
	if(start->m_pleft == current || start->m_pright == current)
		return start;
	BinTreeNode<Type>* temp;
	temp = this->GetParent(start->m_pleft, current);
	if(temp) return temp;
	temp = this->GetParent(start->m_pright, current);
	if(temp) return temp;
	return NULL;
}

template<typename Type> BinTreeNode<Type>* BinaryTree<Type>::GetParent(BinTreeNode<Type> *current){
	return this->GetParent(m_proot,current);
}

template<typename Type> bool BinaryTree<Type>::Insert(const Type item){
	BinTreeNode<Type>* p = new BinTreeNode<Type>(item);
	BinTreeNode<Type>* temp = m_proot;
	if(m_proot == NULL)
	{
		m_proot = p;
		return 1;
	}
	while(1)
	{
		if(item < temp->m_data)
		{
			if(temp->m_pleft == NULL)
			{
				temp->SetLeft(p);
				return 1;
			}
			else
				temp = temp->m_pleft;
		}
		else if(item > temp->m_data)
		{
			if(temp->m_pright == NULL)
			{
				temp->SetRight(p);
				return 1;
			}
			else temp = temp->m_pright;
		}
		else return 0;
	}
	return 0;
}

template<typename Type> BinTreeNode<Type>* BinaryTree<Type>::Find(const Type item) const{
	BinTreeNode<Type>* temp = m_proot;
	if(m_proot == NULL)
		return NULL;
	while(1)
	{
		if(temp->m_data == item)
			return temp;
		if(temp->m_data > item)
			temp = temp->m_pleft;
		else temp = temp->m_pright;
	}
	return NULL;
}

template<typename Type> void BinaryTree<Type>::Print(BinTreeNode<Type> *start, int n){
	if(start==NULL){
		for(int i=0;i<n;i++){
			cout<<"     ";
		}
		cout<<"NULL"<<endl;
		return;
	}
	Print(start->m_pright,n+1);	//print the right subtree
	for(int i=0;i<n;i++){	//print blanks with the height of the node
		cout<<"     ";
	}
	if(n>=0){
		cout<<start->m_data<<"--->"<<endl;//print the node
	}
	Print(start->m_pleft,n+1);	//print the left subtree
}

template<typename Type> BinaryTree<Type>& BinaryTree<Type>::operator=(const BinaryTree<Type> copy){
	if(copy.m_proot != NULL)
		this->m_stop = copy.m_stop;
	m_proot = this->m_proot->Copy(copy.m_proot);
	return *this;
}

template<typename Type> ostream& operator<<(ostream& os,BinaryTree<Type>& out){
	out.Print(out.m_proot);
	return os;
}

template<typename Type> istream& operator>>(istream& is,BinaryTree<Type>& in){
	Type item;
	cout<<"initialize the tree:"<<endl<<"Input data(end with "<<in.m_stop<<"!):";
	while(is>>item && item!=in.m_stop)
		in.Insert(item);
	return is;
}

template<typename Type> bool operator==(const BinaryTree<Type> s,const BinaryTree<Type> t){
	return equal(s.m_proot,t.m_proot);
}

template<typename Type> void BinaryTree<Type>::InOrder(){
	m_proot->InOrder();
}

template<typename Type> void BinaryTree<Type>::PreOrder(){
	m_proot->PreOrder();
}

template<typename Type> void BinaryTree<Type>::PostOrder(){
	m_proot->PostOrder();
}

template<typename Type> int BinaryTree<Type>::Size(){
	return m_proot->Size();
}

template<typename Type> int BinaryTree<Type>::Height(){
	return m_proot->Height();
}

Test.cpp

#include <iostream>
using namespace std;
#include "BinaryTree.h"

int main(){
	BinaryTree<int> tree(-1);
//	int init[10]={3,6,0,2,8,4,9,1,5,7};
	int init[30]={17,6,22,29,14,0,21,13,27,18,2,28,8
		,26,3,12,20,4,9,23,15,1,11,5,19,24,16,7,10,25};
	for(int i=0;i<30;i++){
		tree.Insert(init[i]);
	}
	//cin>>tree;
	cout<<tree<<endl;

	cout<<tree.GetParent(tree.Find(20))->GetData()<<endl;
	cout<<tree.Find(15)->GetRight()->GetData()<<endl;

	cout<<"size="<<tree.Size()<<endl;
	cout<<"height="<<tree.Height()<<endl;

	tree.InOrder();
	cout<<endl<<endl;
	tree.PreOrder();
	cout<<endl<<endl;
	tree.PostOrder();
	cout<<endl<<endl;
	

	BinaryTree<int> tree2=tree;
	cout<<tree2<<endl;

	cout<<tree2.GetParent(tree2.Find(20))->GetData()<<endl;
	cout<<tree2.Find(15)->GetRight()->GetData()<<endl;

	cout<<(tree==tree2)<<endl;
	return 0;
}