二叉树

//二叉树类的异常处理类

#ifndef TREE_EXCEPTION_H_
#define TREE_EXCEPTION_H_
#include<stdexcept>
#include<string>
class TreeException :public std::logic_error
{
	public:
		TreeException(const std::string &message="")
			:std::logic_error(message.c_str())
		{}
};
#endif

//二叉树的头文件

#ifndef BINARY_TREE_H_
#define BINARY_TREE_H_
#include"tree_exception.h"
#include<string>
typedef std::string  ItemType;
typedef void (*FuncType)(ItemType &_item);
class BinaryTree
{
	public:
		//constructor and destructor
		BinaryTree();
		BinaryTree(const ItemType &rootitem);
		BinaryTree(const BinaryTree &tree);
		BinaryTree(const ItemType &rootitem,
				BinaryTree &leftTree,
				BinaryTree &rightTree);
		virtual ~BinaryTree();

		//binary tree operations
		virtual bool empty()const;
		virtual ItemType getRootData()const 
			throw(TreeException);
		virtual void setRootData(ItemType rootitem)
			throw(TreeException);
		virtual void attachLeft(const ItemType &_item)
			throw(TreeException);
		virtual void attachRight(const ItemType &_item)
			throw(TreeException);
		virtual void attachLeftSubtree(BinaryTree &tree)
			throw(TreeException);
		virtual void attachRightSubtree(BinaryTree &tree)
			throw(TreeException);
		virtual void deleteLeftSubtree(BinaryTree &tree)
			throw(TreeException);
		virtual void deleteRightSubtree(BinaryTree &tree)
			throw(TreeException);
		virtual BinaryTree getLeftSubtree()const 
			throw(TreeException);
		virtual BinaryTree getRightSubtree()const
			throw(TreeException); 
		virtual void preorderTraverse(FuncType visit);
		virtual void inorderTraverse(FuncType visit);
		virtual void postorderTraverse(FuncType visit);

		virtual BinaryTree &operator=(const BinaryTree &rhs);
		
	protected:
		struct TreeNode
		{
			TreeNode();
			TreeNode(const ItemType &_item,
			TreeNode *left=NULL,
			TreeNode *right=NULL)
				:item(_item),leftPtr(left),rightPtr(right)
		{}
		ItemType item;
		TreeNode *leftPtr;
		TreeNode *rightPtr;
		};
		BinaryTree(TreeNode *nodePtr);

		void copyTree(TreeNode *treePtr,TreeNode *&newTreePtr)const
			throw(TreeException);
		void destroyTree(TreeNode *&treePtr);

		TreeNode *&rootPtr();
		void setRootPtr(TreeNode *newRoot);
		TreeNode *& getLeftPtr(TreeNode *&nodePtr);
		TreeNode *& getRightPtr(TreeNode *&nodePtr);
		void setChildPtr(TreeNode *nodePtr,
				TreeNode *&leftChildPtr,
				TreeNode *&rightChildPtr);
		void preorder(TreeNode *treePtr,FuncType visit);
		void inorder(TreeNode *treePtr,FuncType visit);
		void postorder(TreeNode *treePtr,FuncType visit);
	

	private:
		TreeNode *root;
};
#endif

//二叉树的实现文件

#include"binary_tree.h"
#include<cstddef>
#include<cassert>
BinaryTree::BinaryTree():root(NULL)
{
}
BinaryTree::BinaryTree(const ItemType &rootitem)
{
	root=new TreeNode(rootitem,NULL,NULL);
	assert(root!=NULL);
}
BinaryTree::BinaryTree(const BinaryTree &tree)
{
	copyTree(tree.root,root);
}
BinaryTree::BinaryTree(const ItemType &rootitem,
		BinaryTree &leftTree,
		BinaryTree &rightTree)
{
	root =new TreeNode(rootitem,NULL,NULL);
	assert(root!=NULL);
	attachLeftSubtree(leftTree);
	attachRightSubtree(rightTree);
}
BinaryTree::BinaryTree(TreeNode *nodePtr)
{
	copyTree(nodePtr,root);
}
BinaryTree::~BinaryTree()
{
	destroyTree(root);
}
bool BinaryTree::empty()const
{
	return(root==NULL);
}
ItemType BinaryTree::getRootData()const
	throw(TreeException)
{
	if(empty())
		throw TreeException("calling getRootData function failed :empty tree");
	return root->item;
}
void BinaryTree::setRootData(ItemType rootitem)
	throw(TreeException)
{
	
	if(empty())
	{
		root=new TreeNode(rootitem,NULL,NULL);
		if(root==NULL)
			throw TreeException("calling setRootData function failed :allocate memory failed ");
	}
	else
		root->item=rootitem;
}
void BinaryTree::attachLeft(const ItemType &_item)
	throw(TreeException)
{
	if(empty())
		throw TreeException("calling attachLeft function failed:empty tree ");
	else if(root->leftPtr!=NULL)
		throw TreeException("calling attachLeft function failed :tree's left child existed ");
	else
	{
		
		root->leftPtr=new TreeNode(_item,NULL,NULL);
		if(root->leftPtr==NULL)
			throw TreeException("calling attachLeft function failed :allocate memory failed ");
	}
}
void BinaryTree::attachRight(const ItemType &_item)
	throw(TreeException)
{
	if(empty())
		throw TreeException("calling attachRight function failed :empty tree");
	else if(root->rightPtr!=NULL)
		throw TreeException("calling attachRight function failed :tree's right child existed ");
	else
	{
		root->rightPtr=new TreeNode(_item,NULL,NULL);
		if(root->rightPtr==NULL)
			throw TreeException("calling attachRight function failed :allocate memory failed ");
	}
}
void BinaryTree::attachLeftSubtree( BinaryTree &tree)
	throw(TreeException)
{
	if(empty())
		throw TreeException("calling attachLeftSubtree function failed :tree is empty ");
	else if(root->leftPtr!=NULL)
		throw TreeException("calling attachLeftSubtree  function failed :tree's right child existed ");
	else
	{	root->leftPtr=tree.root;
		tree.root=NULL;
	}
}
void BinaryTree::attachRightSubtree(BinaryTree &tree)
	throw(TreeException)
{
	if(empty())
		throw TreeException("calling attachRightSubtree function failed :empty tree ");
	else if(root->rightPtr!=NULL)
		throw TreeException("calling attachRightSubtree  function failed :tree's right child existed ");
	else{
	root->rightPtr=tree.root;
	tree.root=NULL;
	}
}
void BinaryTree::deleteLeftSubtree(BinaryTree &tree)throw(TreeException)
{
	if(empty())
		throw TreeException("calling deleteLeftSubtree function failed :emtpy tree");
	else
	{
		tree=BinaryTree(root->leftPtr);
		root->leftPtr=NULL;
	}
}
void BinaryTree::deleteRightSubtree(BinaryTree &tree)
	throw(TreeException)
{
	if(empty())
		throw TreeException("calling deleteRightSubtree function failed :empty tree ");
	else
	{
		tree=BinaryTree(root->rightPtr);
		root->rightPtr=NULL;
	}
}
BinaryTree &BinaryTree::operator=(const BinaryTree &rhs)
{
	if(this==&rhs)
		return *this;
	else
	{
		destroyTree(root);
		copyTree(rhs.root,root);
		return *this;
	}
}

BinaryTree BinaryTree::getLeftSubtree()const
	throw(TreeException)
{
	if(empty())
		throw TreeException("calling getleftSubtree function failed:empty tree ");
	else
	{
		return BinaryTree(root->leftPtr);
	}
}
BinaryTree BinaryTree::getRightSubtree()const
	throw(TreeException)
{
	if(empty())
		throw TreeException("calling getrightSubtree function failed :empty tree ");
	else
		return BinaryTree(root->rightPtr);
}
void BinaryTree::preorderTraverse(FuncType visit)
{
	preorder(root,visit);
}
void BinaryTree::inorderTraverse(FuncType visit)
{
	inorder(root,visit);
}
void BinaryTree::postorderTraverse(FuncType visit)
{
	postorder(root,visit);
}
void BinaryTree::copyTree(TreeNode *treePtr,TreeNode *&newTreePtr)const
	throw(TreeException)
{
	if(treePtr!=NULL)
	{
		newTreePtr =new TreeNode(treePtr->item,NULL,NULL);
		if(newTreePtr==NULL)
			throw TreeException("calling copyTree function failed :allocate memory faild ");
		copyTree(treePtr->leftPtr,newTreePtr->leftPtr);
		copyTree(treePtr->rightPtr,newTreePtr->rightPtr);
	}
	else
		newTreePtr=NULL;
}
void BinaryTree::destroyTree(TreeNode *&treePtr)
{
	if(treePtr!=NULL)
	{
		destroyTree(treePtr->leftPtr);
		destroyTree(treePtr->rightPtr);
		delete treePtr;
		treePtr=NULL;
	}
}
BinaryTree::TreeNode *& BinaryTree::rootPtr()
{
	return root;
}
void BinaryTree::setRootPtr(TreeNode *newRoot)
{
	destroyTree(root);
	root=newRoot;
}
void BinaryTree::setChildPtr(TreeNode *nodePtr,
		TreeNode *&leftChildPtr,
		TreeNode *&rightChildPtr)
{
	destroyTree(nodePtr->leftPtr);
	destroyTree(nodePtr->rightPtr);
	nodePtr->leftPtr=leftChildPtr;
	nodePtr->rightPtr=rightChildPtr;
}
BinaryTree::TreeNode *&BinaryTree::getLeftPtr(TreeNode *&nodePtr)
{
	return nodePtr->leftPtr;
}
BinaryTree::TreeNode *&BinaryTree::getRightPtr(TreeNode *&nodePtr)
{
	return nodePtr->rightPtr;
}
void BinaryTree::preorder(TreeNode *treePtr,FuncType visit)
{
	if(treePtr!=NULL)
	{
		visit(treePtr->item);
		preorder(treePtr->leftPtr,visit);
		preorder(treePtr->rightPtr,visit);
	}
}
void BinaryTree::inorder(TreeNode *treePtr,FuncType visit)
{
	if(treePtr!=NULL)
	{
		inorder(treePtr->leftPtr,visit);
		visit(treePtr->item);
		inorder(treePtr->rightPtr,visit);
	}
}
void BinaryTree::postorder(TreeNode *treePtr,FuncType visit)
{
	if(treePtr!=NULL)
	{
		postorder(treePtr->leftPtr,visit);
		postorder(treePtr->rightPtr,visit);
		visit(treePtr->item);
	}
}