#include<iostream>


using namespace std;

tempalte <class elemType>
struct nodeType 
{
elemType info;
nodeType<elemType>*llink;
nodeType<elemType>*rlink;
};

////CLASS

tempalte<class elemType>
class binaryTreeType
{
	public:
		const binaryTreeType<elemType>& operator=
			(const binaryTreeType<elemType>&)
			 
		bool isEmpty();	
		void inorderTraversal();
		void preorderTraversal();
		void postorderTraversal();

		int TreeHeight();
		int TreeNdeCount();
		int TreeLeavesCount();
		
		void destroyTree();

		binaryTreeType(const binaryTreeType<elemType>&otherTree);

			binaryTreeType();
 
			~binaryTreeType();
	protected:
		nodeType<elemType>*root;
	private:
		void copyTree(nodeType<elemType>* &copiedTreeRoot,nodeType<elemType>* otherTreeRoot);

		void destroy(nodeType<elemType>* &p);
		
		void inorder(nodeType<elemType>*p);
        void preorder(nodeType<elemType>*p);
		void postorder(nodeType<elemType>*p);
		int height(nodeType<elemType>*p);
		int max (int x, int y );
		int nodeCount(nodeType<elemType>*p);
		int leavesCount(nodeType<elemType>*p);
};

tempalte<class elemType>
bool binaryTreeType <elemType>::isEmpty()
{
	return (root==NULL);
}

tempalte<class elemType>
bool binaryTreeType <elemType>::binaryTreeType()
{
	root==NULL;
}

tempalte<class elemType>
void binaryTreeType<elemType>::inorderTraversal()
{
	inorder(root);//call inorder function with root parameter

}


tempalte <class elemType>
void binaryTreeType<elemType>::preorderTraversal()
{
preorder(root);
}

tempalte<class elemType>
void binaryTreeType<elemType>::postorderTraversal()
{
	postorder(root);
}

tempalte<class elemType>
	int binaryTreeType<elemType>::TreeHeight()
{
	return height(root);
}

tempalte<class elemType>
	int binaryTreeType<elemType>::TreeNdeCount()
{
	return nodeCount(root);
}

tempalte<class elemType>
	int binaryTreeType<elemType>::TreeLeavesCount()
{
	return leavesCount(root);
}

tempalte<class elemType>
	int binaryTreeType<elemType>::inorder(nodeType<elemType>*p)
{
	if(p!=NULL)
	{
		inorder(p->llink)
		cout<<p->info<<" ";
        inorder(p->rlink);
	}
}

tempalte<class elemType>
	int binaryTreeType<elemType>::preorder(nodeType<elemType>*p)
{
	if(p!=NULL)
	{
        cout<<p->info<<" ";
		preorder(p->llink)
		
        preorder(p->rlink);
	}
}


tempalte<class elemType>
	int binaryTreeType<elemType>::postorder(nodeType<elemType>*p)
{
	if(p!=NULL)
	{
		postorder(p->llink)
	
        postorder(p->rlink);

		cout<<p->info<<" ";
	}
}

tempalte<class elemType>
	int binaryTreeType<elemType>::height(nodeType<elemType>*p)
{
	if(p==NULL)
		return 0;
	else 
		return 1+max(height(p->llink),(height(p->rlink));
}

tempalte<class elemType>
	int binaryTreeType<elemType>::max(int x,int y)
{
	if(x>=y)
		return x;
	else 
		return y;
}

tempalte<class elemType>
int binaryTreeType<elemType>::leavesCount(nodeType<elemType>*p)
{
	if(p=NULL)
		return 0;
	else
		if (p->llink==NULL&&p->rlink==NULL)
			return 1;
	
	else
		return ( leavesCount(p->llink)+ leavesCount(p->rlink));
}

void main()
{

binaryTreeType<int> shoq;
shoq.inorderTraversal()
shoq.leavesCount(nodeType<elemType>*p);
}