binarytree_cpp.h

哈弗曼编码的课程设计报告

#ifndef BINARYTREE_CPP
#define BINARYTREE_CPP

#include"BinaryTree_h.h"

template<class T>
BinaryTree_T<T>::BinaryTree_T(void)
{
	m_root=NULL;
}

template<class T>
BinaryTree_T<T>::BinaryTree_T(const T&element)
{
	m_root=new TreeNode_T<T>(element);
}

template<class T>
BinaryTree_T<T>::BinaryTree_T(const BinaryTree_T<T> &bt)
{
	m_root=CopyBinaryTree(bt.m_root);
}

template<class T>
BinaryTree_T<T>::~BinaryTree_T(void)
{
	Clear();
}

template<class T>
BinaryTree_T<T>& BinaryTree_T<T>::operator =(const BinaryTree_T<T> &bt)
{
	if (this!=&bt)
	{
		Clear();
		m_root=CopyBinaryTree(bt.m_root);
	}
	return *this;
}

template<class T>
TreeNode_T<T>* BinaryTree_T<T>::CopyBinaryTree(TreeNode_T<T>*ptr)
{
	if (ptr==NULL)
		return NULL;
	TreeNode_T<T> *p=new TreeNode_T<T>(ptr->Data());
	p->LeftChild()=CopyBinaryTree(ptr->LeftChild());
	p->RightChild()=CopyBinaryTree(ptr->RightChild());
	
	return p;
}

template<class T>
void BinaryTree_T<T>::MakeTree(const T&data,BinaryTree_T<T>&lhs,
											 BinaryTree_T<T>&rhs)
{
	if (&lhs==&rhs)
	{
		cout<<"构造树失败!"<<endl;
		return;
	}
	else
	{
		Clear();
		m_root=new TreeNode_T<T>(data,lhs.m_root,rhs.m_root);
		lhs.m_root=NULL;
		rhs.m_root=NULL;
	}
}

template<class T>
void BinaryTree_T<T>::BreakTree(T&data,BinaryTree_T<T>&lhs,
										BinaryTree_T<T>&rhs)
{
	if (!m_root||&lhs==&rhs||lhs.m_root||rhs.m_root)
	{
		cout<<"拆开树失败!"<<endl;
		return;
	}
	else
	{
		data=m_root->Data();
		lhs.m_root=m_root->LeftChild();
		rhs.m_root=m_root->RightChild();
		m_root->LeftChild()=NULL;
		m_root->RightChild()=NULL;
		Clear();
	}
}

template<class T>
void BinaryTree_T<T>::Clear(void)
{
	Clear(m_root);
	m_root=NULL;
}

template<class T>
void BinaryTree_T<T>::Clear(TreeNode_T<T>*ptr)
{
	if (ptr!=NULL)
	{
		Clear(ptr->LeftChild());
		Clear(ptr->RightChild());
		delete ptr;
	}
}

template<class T>
void BinaryTree_T<T>::Visit(const TreeNode_T<T>*ptr)
{
	cout<<ptr->Data()<<" "<<endl;
}

template<class T>
void BinaryTree_T<T>::PreOrder(void)
{
	PreOrder(m_root);
}

template<class T>
void BinaryTree_T<T>::PreOrder(TreeNode_T<T>*ptr)
{
	if (ptr!=NULL)
	{
		Visit(ptr);
		PreOrder(ptr->LeftChild());
		PreOrder(ptr->RightChild());
	}
}

template<class T>
void BinaryTree_T<T>::InOrder(void)
{
	InOrder(m_root);
}

template<class T>
void BinaryTree_T<T>::InOrder(TreeNode_T<T>*ptr)
{
	if (ptr!=NULL)
	{
		InOrder(ptr->LeftChild());
		Visit(ptr);
		InOrder(ptr->RightChild());
	}
}

template<class T>
void BinaryTree_T<T>::PostOrder(void)
{
	PostOrder(m_root);
}

template<class T>
void BinaryTree_T<T>::PostOrder(TreeNode_T<T>*ptr)
{
	if (ptr!=NULL)
	{
		PostOrder(ptr->LeftChild());
		PostOrder(ptr->RightChild());
		Visit(ptr);
	}
}

template<class T>
TreeNode_T<T>* BinaryTree_T<T>::GetTreeNode(void)
{
	return m_root;
}
#endif