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

template<class Type>
class BinaryTree;

template<class Type>
class BinaryNode{      //结点结构
	friend class BinaryTree<Type>;
	public:
		BinaryNode():left(0),right(0){}
		BinaryNode(Type item,BinaryNode<Type> *L=0,BinaryNode<Type> *R=0):data(item),left(L),right(R){}
		~BinaryNode(){}
		Type GetData()const {return data;}
		BinaryNode<Type> *GetLeft() const {return left;}
		BinaryNode<Type> *GetRight() const {return right;}
		void SetData(const Type &item) {data = item;}
		void SetLeft(BinaryNode<Type> *L) {left = L;}
		void SetRight(BinaryNode<Type> *R) {right = R;}
		int Size(const BinaryNode<Type> *T) const;
		int Hight(const BinaryNode<Type> *T) const;
		void PrintPreOrder() const;   //先序遍历（输出）
		void PrintPostOrder() const;  //后序遍历（输出）
		void PrintInOrder() const;    //中序遍历（输出）
		BinaryNode<Type> *Duplicate() const;
	private:
		Type data;
	    BinaryNode<Type> *left, *right;
};

template<class Type>
BinaryNode<Type> *BinaryNode<Type>::Duplicate() const{
	BinaryNode<Type> *root = new BinaryNode<Type>(data);
	if(left != 0) root->left = left->Duplicate();
	if(right != 0) root->right = right->Duplicate();
	return root;
}

template<class Type>
void BinaryNode<Type>::PrintPreOrder() const {  //先序遍历（输出）
	cout << setw(3) << data;
	if(left != 0) left->PrintPreOrder();
	if(right != 0) right->PrintPreOrder();
}

template<class Type>
void BinaryNode<Type>::PrintInOrder() const {  //中序遍历（输出）
	if(left != 0) left->PrintInOrder();
	cout << setw(3) << data;
	if(right != 0) right->PrintInOrder();
}

template<class Type>
void BinaryNode<Type>::PrintPostOrder() const {  //后序遍历（输出）

	if(left != 0) left->PrintPostOrder();
	if(right != 0) right->PrintPostOrder();
	cout << setw(3) << data;
}

template<class Type>
Type Max(const Type u, const Type v){
	if(u > v) return u;
	else return v;
}

template<class Type>
int BinaryNode<Type>::Size(const BinaryNode<Type> *T) const{
	if(T == o) return 0;
	else return 1 + Size(T->left) + Size(T->right);
}

template<class Type>
int BinaryNode<Type>::Hight(const BinaryNode<Type> *T) const{
	if(T == o) return 0;
	else return 1 + Max(Hight(T->left) + Hight(T->right));
}

template<class Type>
class BinaryTree{
	public:
		BinaryTree():root(0){}
		BinaryTree(const Type &value){root = new BinaryNode<Type>(value);}
		~BinaryTree(){DelTree(root);}
		bool IsEmpty() const {return root == 0;}
		const BinaryNode<Type> *Getroot() const {return root;}
		void MakeEmpty(){DelTree(root); root = 0;}
		const BinaryTree<Type> &operator=(const BinaryTree<Type> &T);
	private:
		BinaryNode<Type> *root;
		BinaryTree(const BinaryTree<Type> &);
		void DelTree(BinaryNode<Type> *T);
};

template<class Type>
const BinaryTree<Type> &BinaryTree<Type>::operator=(const BinaryTree<Type> &T){
	if(this != &T){
		DelTree(root);
		if(T.root != 0) root = T.root->Duplicate();
	}
	return *this;
}

template<class Type>
BinaryTree<Type>::BinaryTree(const BinaryTree<Type> &T){
	root = T.root->Duplicate();
}

template<class Type>
void BinaryTree<Type>::DelTree(BinaryNode<Type> *T){
	if(T != 0){
		DelTree(T->left);
		DelTree(T->right);
		delete T;
	}
}

void main(void)
{
;	//按实际情况给出
}