二叉树操作

#ifndef _BINARYTREE_NODE_
#define _BINARYTREE_NODE_

//二叉树节点，包含数据，左节点，有节点
template<class T> class CBinaryTreeNode
{
public:
 CBinaryTreeNode()
 {
  data = 0;
  left = NULL;
  right = NULL
 }
 CBinaryTreeNode(const T& data)
 {
  this->data = data;
  left = NULL;
  right = NULL;
 }
 CBinaryTreeNode(const T& data, CBinaryTreeNode<T> *left, CBinaryTreeNode<T> *right)
 {
  this->data = data;
  this->left = left;
  this->right = right;
 }

public:
 T data;
 CBinaryTreeNode<T> *left;
 CBinaryTreeNode<T> *right;
};

#endif

 

#include <iostream>
#include "binarytreenode.h"
#include "queue.h"
#include "stack.h"
#include <assert.h>
using namespace std;

template<class T> class CBinaryTree  
{  
private :
 CBinaryTree()// 必须定义, 且为private.
 {
  root == NULL;
  nodenum = 0;
 }  
 CBinaryTree(const CBinaryTree&);            // 不实现. 
 CBinaryTree& operator=(const CBinaryTree&); // 不实现.  
 ~CBinaryTree()// 可声明为public, 但这里声明为private没有错, 可被调用.
 {
  BinaryTree_Destroy(false);
 }

private:
 CBinaryTreeNode<T> *root;
 int nodenum;

public :
 static CBinaryTree& GetInstance()
 {
  static CBinaryTree theSingleton;
  return theSingleton;
 }

public:/**********************************************二叉树建立及销毁*****************************************/

 //二叉树的创建，bRecursion指示是否使用递归方法创建。
 //目前创建的二叉树是完全二叉树。
 void BinaryTree_CreateFullTree(T data[], int n, bool bRecursion);

 //销毁二叉树
 void BinaryTree_Destroy(bool bRecursion);

private:
 //递归创建完全二叉树
 CBinaryTreeNode<T>* BinaryTree_CreateFullTree_Recursion(T *data, int num, int n);
 //非递归创建完全二叉树
 void BinaryTree_CreateFullTree_Unrecursion(T *data, int num);

 //递归销毁二叉树
 void BinaryTree_Destroy_Recursion(CBinaryTreeNode<T>* node);
 //非递归销毁二叉树
 void BinaryTree_Destroy_Unrecursion(CBinaryTreeNode<T>* node);

public:/**********************************************二叉树遍历***********************************************/

 //先序遍历，bRecursion指示是否使用递归
 void BinaryTree_PreOrder(bool bRecursion);

 //中序遍历，bRecursion指示是否使用递归
 void BinaryTree_InOrder(bool bRecursion);

 //后序遍历，bRecursion指示是否使用递归
 void BinaryTree_PostOrder(bool bRecursion);

 //层次遍历
 void BinaryTree_LayerOrder();
 
private:
 
 //递归先序遍历二叉树
 void BinaryTree_PreOrder_Recursion( CBinaryTreeNode<T> *node );
 //非递归先序遍历二叉树
 void BinaryTree_PreOrder_Unrecursion( CBinaryTreeNode<T> *node );

 //递归中序遍历二叉树
 void BinaryTree_InOrder_Recursion( CBinaryTreeNode<T> *node );
 //非递归中序遍历二叉树
 void BinaryTree_InOrder_Unrecursion( CBinaryTreeNode<T> *node );

 //递归后序遍历二叉树
 void BinaryTree_PostOrder_Recursion( CBinaryTreeNode<T> *node );
 //非递归后序遍历二叉树
 void BinaryTree_PostOrder_Unrecursion( CBinaryTreeNode<T> *node );

public:/**********************************************二叉树操作***********************************************/

 //求二叉树高度
 void BinaryTree_Height(bool bRecursion);

 //节点数，总的节点数，叶子节点数，非叶子节点数
 void BinaryTree_NodeCount(bool bRecursion);

 //复制二叉树
 void BinaryTree_Copy(bool bRecursion);

 //比较二叉树
 void BinaryTree_Equal(bool bRecursion);

 //二叉树叶子节点交换
 void BinaryTree_NodeExchange(bool bRecursion);

private:

 //递归求二叉树高度
 int BinaryTree_Height_Recursion( CBinaryTreeNode<T> *node );
 //非递归求二叉树高度
 int BinaryTree_Height_Unrecursion( CBinaryTreeNode<T> *node );

 //递归计算节点数，总的节点数，叶子节点数，非叶子节点数
 void BinaryTree_NodeCount_Recursion( CBinaryTreeNode<T> *node, int& N, int& NL, int& NR, int& NLR );
 //非递归计算节点数，总的节点数，叶子节点数，非叶子节点数
 void BinaryTree_NodeCount_Unrecursion( CBinaryTreeNode<T> *node, int& N, int& NL, int& NR, int& NLR );

 //递归复制二叉树
 CBinaryTreeNode<T>* BinaryTree_Copy_Recursion( CBinaryTreeNode<T> *node );
 //非递归复制二叉树
 CBinaryTreeNode<T>* BinaryTree_Copy_Unrecursion( CBinaryTreeNode<T> *node );

 //递归比较二叉树
 bool BinaryTree_Equal_Recursion( CBinaryTreeNode<T> *src, CBinaryTreeNode<T> *dst );
 //非递归比较二叉树
 bool BinaryTree_Equal_Unrecursion( CBinaryTreeNode<T> *src, CBinaryTreeNode<T> *dst );

 //递归二叉树叶子节点交换
 void BinaryTree_NodeExchange_Recursion( CBinaryTreeNode<T> *node );
 //非递归二叉树叶子节点交换
 void BinaryTree_NodeExchange_Unrecursion( CBinaryTreeNode<T> *node );

public:/**************************************使用前中后序遍历进行算术运算**************************************/

 //传入前序方式表达的算术表达式进行记录  /6-53 == 6/(5-3)
 void PreOrder_Arithmetic_Operations(char *oper);

 //传入中序方式表达的算术表达式进行记录6/(5-3)
 //顺序扫描初始表达式，当遇到运算量时，可直接将其送入输出队列中；当遇到运算符时，要与栈顶的运算符进行优先级的比较，
 //如果前者高则进栈，如果栈顶的运算 符优先级高（或等于）可将其从栈中弹出并送入输出队列中，然后再将当前运算符入栈；
 //当遇到左括号时即入栈，当遇到右括号时将与其配对的左括号上面的运算符 全部依次弹出送入输出队列中，再删除该左括号；
 //当遇到‘＃’时将栈中运算符全部依次弹出送入输出队列中。
 //经过第一阶段的处理后初始表达式“9-(2+ 4*7)/5+3#”将转换成后缀表达式：“9247*+5/-3+”。

 //对逆波兰表示求表达式值的算法较为简单：从队列中取出元素，若为运算量则进栈；
 //否则为运算符，从运算量栈中依次弹出二个运算量，运算后将结构推入栈中，重复进行直至队列为空，计算结果在栈中。
 void InOrder_Arithmetic_Operations(char *oper);

 //传入后序方式表达的算术表达式进行记录653-/
 void PostOrder_Arithmetic_Operations(char *oper);

private:
 //判断是否为运算符
 bool isOperator(char oper);

 //根据运算符进行运算
 int operation(int loper, int roper, char oper);

 //判断运算符优先级，+-为一级， */为二级
 int priority(char oper);
};

template<class T> void CBinaryTree<T>::BinaryTree_CreateFullTree(T data[], int n, bool bRecursion)
{
 if (bRecursion)
 {
  BinaryTree_CreateFullTree_Recursion(data, 0, n);
 }
 else
 {
  BinaryTree_CreateFullTree_Unrecursion(data, n);
 }
 nodenum = n;
}

template<class T> CBinaryTreeNode<T>* CBinaryTree<T>::BinaryTree_CreateFullTree_Recursion(T *data, int num, int n)
{
 CBinaryTreeNode<T> *tmpNode = NULL;
 if (num < n)
 {
  tmpNode = new CBinaryTreeNode<T>(data[num]);
  if (root == NULL)
  {
   root = tmpNode;
  }
  tmpNode->left = BinaryTree_CreateFullTree_Recursion(data, 2*num+1, n);
  tmpNode->right = BinaryTree_CreateFullTree_Recursion(data, 2*num+2, n);
 }
 return tmpNode;
}

template<class T> void CBinaryTree<T>::BinaryTree_CreateFullTree_Unrecursion(T *data, int num)
{
 if (root == NULL)
 {
  root = new CBinaryTreeNode<T>(data[0]);
 }
 CQueue<CBinaryTreeNode<T>*> *queue = new CQueue<CBinaryTreeNode<T>*>(2*num);
 CQueue<int> *queueindex = new CQueue<int>(2*num);
 assert(queue!=NULL, "allocate memeory failed!/n");
 assert(queueindex!=NULL, "allocate memeory failed!/n");

 queue->enqueue(root);
 queueindex->enqueue(0);
 int curnum = 0;
 while (!queue->empty())
 {
  CBinaryTreeNode<T> *tmpNode = queue->dequeue();
  curnum = queueindex->dequeue();
  if (2*curnum + 1 < num)
  {
   tmpNode->left = new CBinaryTreeNode<T>(data[2*curnum + 1]);
   queue->enqueue(tmpNode->left);
   queueindex->enqueue(2*curnum+1);
  }
  else
  {
   tmpNode->right = NULL;
  }
  if (2*curnum + 2 < num)
  {
   tmpNode->right = new CBinaryTreeNode<T>(data[2*curnum + 2]);
   queue->enqueue(tmpNode->right);
   queueindex->enqueue(2*curnum+2);
  }
  else
  {
   tmpNode->right = NULL;
  }
 }

 delete queue;
 delete queueindex;
}

template<class T> void CBinaryTree<T>::BinaryTree_Destroy(bool bRecursion)
{
 if (root == NULL)
 {
  return;
 }

 cout<<"destroy tree:/t";

 if (bRecursion)
 {
  BinaryTree_Destroy_Recursion(root);
 }
 else
 {
  BinaryTree_Destroy_Unrecursion(root);
 }

 root = NULL;
 nodenum = 0;

 cout<<" success"<<endl;
}

template<class T> void CBinaryTree<T>::BinaryTree_Destroy_Recursion(CBinaryTreeNode<T>* node)
{
 if (node == NULL)
 {
  return;
 }
 else
 {
  BinaryTree_Destroy_Recursion(node->left);
  BinaryTree_Destroy_Recursion(node->right);
  delete node;
  node == NULL;
 }
}

template<class T> void CBinaryTree<T>::BinaryTree_Destroy_Unrecursion(CBinaryTreeNode<T>* node)
{
 if (node == NULL)
 {
  return ;
 }

 CQueue<CBinaryTreeNode<T>*> *queue = new CQueue<CBinaryTreeNode<T>*>(2*nodenum);
 assert(queue!=NULL, "allocate memory failed/n");

 CBinaryTreeNode<T> *tmpNode = node;
 int currentLen = 0;

 queue->enqueue(tmpNode);
 currentLen = 1;

 while (currentLen > 0)
 {
  int tmpLen = 0;
  for (int index=0; index<currentLen; index++)
  {
   tmpNode = queue->dequeue();
   if (tmpNode->left != NULL)
   {
    queue->enqueue(tmpNode->left);
    tmpLen++;
   }
   if (tmpNode->right != NULL)
   {
    queue->enqueue(tmpNode->right);
    tmpLen++;
   }
   delete tmpNode;
   tmpNode = NULL;
  }
  currentLen = tmpLen;
 }

 delete queue;

}

template<class T> void CBinaryTree<T>::BinaryTree_PreOrder(bool bRecursion)
{  
 cout<<"pre order:/t";

 if (root == NULL)
 {
  return;
 }

 CBinaryTreeNode<T> *tmpNode = root;

 if (bRecursion)
 {
  BinaryTree_PreOrder_Recursion(tmpNode);
 }
 else
 {
  BinaryTree_PreOrder_Unrecursion(tmpNode);
 }
 
 cout<<endl;
}

template<class T> void CBinaryTree<T>::BinaryTree_PreOrder_Recursion( CBinaryTreeNode<T> *node )
{
 if (node != NULL)
 {
  cout<<" "<<node->data;
  BinaryTree_PreOrder_Recursion(node->left);
  BinaryTree_PreOrder_Recursion(node->right);
 }
}
template<class T> void CBinaryTree<T>::BinaryTree_PreOrder_Unrecursion( CBinaryTreeNode<T> *node )
{
 CStack<CBinaryTreeNode<T>*> *stack = new CStack<CBinaryTreeNode<T>*>(2*nodenum);
 assert(stack!=NULL, "allocate memory failed/n");

 stack->push(node);
 while (!stack->empty())
 {
  CBinaryTreeNode<T> *tmpNode = stack->pop();
  cout<<" "<<tmpNode->data;
  if (tmpNode->right != NULL)
  {
   stack->push(tmpNode->right);
  }
  if (tmpNode->left != NULL)
  {
   stack->push(tmpNode->left);
  }
 }

 delete stack;
}

template<class T> void CBinaryTree<T>::BinaryTree_InOrder(bool bRecursion)
{
 cout<<"in order:/t";

 if (root == NULL)
 {
  return;
 }

 CBinaryTreeNode<T> *tmpNode = root;

 if (bRecursion)
 {
  BinaryTree_InOrder_Recursion(tmpNode);
 }
 else
 {
  BinaryTree_InOrder_Unrecursion(tmpNode);
 }

 cout<<endl;
}

template<class T> void CBinaryTree<T>::BinaryTree_InOrder_Recursion( CBinaryTreeNode<T> *node )
{
 if (node != NULL)
 {
  BinaryTree_InOrder_Recursion(node->left);
  cout<<" "<<node->data;
  BinaryTree_InOrder_Recursion(node->right);
 }
}
template<class T> void CBinaryTree<T>::BinaryTree_InOrder_Unrecursion( CBinaryTreeNode<T> *node )
{
 CStack<CBinaryTreeNode<T>*> *stack = new CStack<CBinaryTreeNode<T>*>(2*nodenum);
 assert(stack!=NULL, "allocate memory failed/n");

 CBinaryTreeNode<T>* tmpNode = node;

 while (true)
 {
  while (tmpNode != NULL)
  {
   stack->push(tmpNode);
   tmpNode = tmpNode->left;
  }

  if (!stack->empty())
  {
   tmpNode = stack->pop();
  }
  else
  {
   break;
  }

  cout<<" "<<tmpNode->data;
  tmpNode = tmpNode->right;
 }

 delete stack;
}

template<class T> void CBinaryTree<T>::BinaryTree_PostOrder(bool bRecursion)
{
 cout<<"post order:/t";

 if (root == NULL)
 {
  return;
 }

 CBinaryTreeNode<T> *tmpNode = root;

 if (bRecursion)
 {
  BinaryTree_PostOrder_Recursion(tmpNode);
 }
 else
 {
  BinaryTree_PostOrder_Unrecursion(tmpNode);
 }

 cout<<endl;
}

template<class T> void CBinaryTree<T>::BinaryTree_PostOrder_Recursion( CBinaryTreeNode<T> *node )
{
 if (node != NULL)
 {
  BinaryTree_PostOrder_Recursion(node->left);
  BinaryTree_PostOrder_Recursion(node->right);
  cout<<" "<<node->data;
 }
}
template<class T> void CBinaryTree<T>::BinaryTree_PostOrder_Unrecursion( CBinaryTreeNode<T> *node )
{
 CStack<CBinaryTreeNode<T>*> *stack = new CStack<CBinaryTreeNode<T>*>(2*nodenum);
 assert(stack!=NULL, "allocate memory failed/n");

 CBinaryTreeNode<T>* tmpNode = node;
 CBinaryTreeNode<T>* pNode = NULL;
 CBinaryTreeNode<T>* lastVistiNode = NULL;

 while (true)
 {
  while (tmpNode != NULL)
  {
   stack->push(tmpNode);
   tmpNode = tmpNode->left;
  }

  if (!stack->empty())
  {
   pNode = stack->peek();
  }
  else
  {
   break;
  }

  if (pNode->right == NULL || pNode->right == lastVistiNode)
  {
   cout<<" "<<pNode->data;
   lastVistiNode = stack->pop();
  }
  else
  {
   tmpNode = pNode->right;
  }
 }

 delete stack;
}

template<class T> void CBinaryTree<T>::BinaryTree_LayerOrder()
{
 cout<<"LayerOrder:/t";

 if (root == NULL)
 {
  return;
 }

 CQueue<CBinaryTreeNode<T>*> *queue = new CQueue<CBinaryTreeNode<T>*>(2*nodenum);
 assert(queue!=NULL, "allocate memory failed/n");

 CBinaryTreeNode<T> *tmpNode = root;

 queue->enqueue(tmpNode);
 int currentLen = 1;

 while (currentLen > 0)
 {
  int tmpLen = 0;
  for (int index=0; index<currentLen; index++)
  {
   tmpNode = queue->dequeue();
   cout<<" "<<tmpNode->data;
   if (tmpNode->left != NULL)
   {
    queue->enqueue(tmpNode->left);
    tmpLen++;
   }
   if (tmpNode->right != NULL)
   {
    queue->enqueue(tmpNode->right);
    tmpLen++;
   }
  }
  currentLen = tmpLen;
 }

 cout<<endl;

 delete queue;

 return;
}

template<class T> void CBinaryTree<T>::BinaryTree_Height(bool bRecursion)
{
 cout<<"tree height:/t";
 CBinaryTreeNode<T> *tmpNode = root;

 if (bRecursion)
 {
  cout<<" "<<BinaryTree_Height_Recursion(tmpNode);
 }
 else
 {
  cout<<" "<<BinaryTree_Height_Unrecursion(tmpNode);
 }

 cout<<endl;
}

template<class T> int CBinaryTree<T>::BinaryTree_Height_Recursion( CBinaryTreeNode<T> *node )
{
 if (node==NULL)
  return 0;
 int lheight=BinaryTree_Height_Recursion(node->left);
 int rheifht=BinaryTree_Height_Recursion(node->right);
 if (lheight>rheifht)
 {
  return (lheight+1);
 }
 return (rheifht+1);
}

template<class T> int CBinaryTree<T>::BinaryTree_Height_Unrecursion( CBinaryTreeNode<T> *node )
{
 if (node == NULL)
 {
  return 0;
 }

 CQueue<CBinaryTreeNode<T>*> *queue = new CQueue<CBinaryTreeNode<T>*>(2*nodenum);
 assert(queue!=NULL, "allocate memory failed/n");

 CBinaryTreeNode<T> *tmpNode = node;

 int currentHeight = 0;
 int currentLen = 0;

 queue->enqueue(tmpNode);
 currentHeight = 1;
 currentLen = 1;

 while (currentLen > 0)
 {
  int tmpLen = 0;
  for (int index=0; index<currentLen; index++)
  {
   tmpNode = queue->dequeue();
   if (tmpNode->left != NULL)
   {
    queue->enqueue(tmpNode->left);
    tmpLen++;
   }
   if (tmpNode->right != NULL)
   {
    queue->enqueue(tmpNode->right);
    tmpLen++;
   }
  }
  currentLen = tmpLen;
  if (currentLen != 0)
  {
   currentHeight++;
  }
 }

 delete queue;

 return currentHeight;
}

template<class T> void CBinaryTree<T>::BinaryTree_NodeCount(bool bRecursion)
{
 cout<<"Node Count:/t";

 if (root == NULL)
 {
  return;
 }

 int N = 0;
 int NL = 0;
 int NR = 0;
 int NLR = 0;;
 if (bRecursion)
 {
  BinaryTree_NodeCount_Recursion(root, N, NL, NR, NLR);
 }
 else
 {
  BinaryTree_NodeCount_Unrecursion(root, N, NL, NR, NLR);
 }

 cout<<" TOTAL:"<<N+NL+NR+NLR<<"/tLEAF:"<<N<<"/tL:"<<NL<<"/tR:"<<NR<<"/tLR:"<<NLR;

 cout<<endl;
}

template<class T> void CBinaryTree<T>::BinaryTree_NodeCount_Recursion( CBinaryTreeNode<T> *node, int& N, int& NL, int& NR, int& NLR )
{
 if (node == NULL)
 {
  return;
 }
 else
 {
  if (node->left != NULL && node->right != NULL)
  {
   NLR++;
  }
  else if (node->left != NULL)
  {
   NL++;
  }
  else if (node->right != NULL)
  {
   NR++;
  }
  else
  {
   N++;
  }
  BinaryTree_NodeCount_Recursion(node->left, N, NL, NR, NLR);
  BinaryTree_NodeCount_Recursion(node->right, N, NL, NR,NLR);
 }
}

template<class T> void CBinaryTree<T>::BinaryTree_NodeCount_Unrecursion( CBinaryTreeNode<T> *node, int& N, int& NL, int& NR, int& NLR )
{
 CStack<CBinaryTreeNode<T>*> *stack = new CStack<CBinaryTreeNode<T>*>(2*nodenum);
 assert(stack != NULL);

 CBinaryTreeNode<T> *tmpNode = node;
 stack->push(tmpNode);

 while (!stack->empty())
 {
  tmpNode = stack->pop();
  if (tmpNode->left != NULL && tmpNode->right != NULL)
  {
   NLR++;
  }
  else if (tmpNode->left != NULL)
  {
   NL++;
  }
  else if (tmpNode->right != NULL)
  {
   NR++;
  }
  else
  {
   N++;
  }

  if (tmpNode->right != NULL)
  {
   stack->push(tmpNode->right);
  }
  if (tmpNode->left != NULL)
  {
   stack->push(tmpNode->left);
  }
 }

 return;
}

template<class T> void CBinaryTree<T>::BinaryTree_Copy(bool bRecursion)
{
 cout<<"copy tree:/t";

 if (root == NULL)
 {
  return;
 }

 CBinaryTreeNode<T>* tmpRoot = NULL;
 if (bRecursion)
 {
  tmpRoot = BinaryTree_Copy_Recursion(root);
 }
 else
 {
  tmpRoot = BinaryTree_Copy_Unrecursion(root);
 }

 BinaryTree_PreOrder_Recursion(tmpRoot);
 BinaryTree_Destroy_Recursion(tmpRoot);

 cout<<endl;
}

template<class T> CBinaryTreeNode<T>* CBinaryTree<T>::BinaryTree_Copy_Recursion( CBinaryTreeNode<T> *node )
{

 CBinaryTreeNode<T> *tmpNode = NULL;

 if (node == NULL)
 {
  return NULL;
 }

 tmpNode = new CBinaryTreeNode<T>(node->data);

 if (node->left != NULL)
 {
  tmpNode->left = BinaryTree_Copy_Recursion(node->left);
 }
 if (node->right != NULL)
 {
  tmpNode->right = BinaryTree_Copy_Recursion(node->right);
 }

 return tmpNode;
}

template<class T> CBinaryTreeNode<T>* CBinaryTree<T>::BinaryTree_Copy_Unrecursion( CBinaryTreeNode<T> *node )
{
 if (node == NULL)
 {
  return NULL;
 }
 CBinaryTreeNode<T>* orgNode = node;

 CQueue<CBinaryTreeNode<T>*> *orgqueue = new CQueue<CBinaryTreeNode<T>*>(2*nodenum);
 assert(orgqueue!=NULL, "allocate memory failed/n");
 CQueue<CBinaryTreeNode<T>*> *tmpqueue = new CQueue<CBinaryTreeNode<T>*>(2*nodenum);
 assert(tmpqueue!=NULL, "allocate memory failed/n");

 CBinaryTreeNode<T>* tmpRoot = new CBinaryTreeNode<T>(orgNode->data);
 CBinaryTreeNode<T>* tmpNode = tmpRoot;
 CBinaryTreeNode<T>* tmpLNode = NULL;
 CBinaryTreeNode<T>* tmpRNode = NULL;

 orgqueue->enqueue(orgNode);
 tmpqueue->enqueue(tmpNode);

 while (!orgqueue->empty())
 {
  orgNode = orgqueue->dequeue();
  tmpNode = tmpqueue->dequeue();

  if (orgNode->left != NULL)
  {
   orgqueue->enqueue(orgNode->left);

   tmpLNode = new CBinaryTreeNode<T>(orgNode->left->data);
   tmpNode->left = tmpLNode;
   tmpqueue->enqueue(tmpLNode);
  }
  else
  {
   tmpNode->left = NULL;
  }
  if (orgNode->right != NULL)
  {
   orgqueue->enqueue(orgNode->right);

   tmpRNode = new CBinaryTreeNode<T>(orgNode->right->data);
   tmpNode->right = tmpRNode;
   tmpqueue->enqueue(tmpRNode);
  }
  else
  {
   tmpNode->right = NULL;
  }
 }

 return tmpRoot;
}

template<class T> void CBinaryTree<T>::BinaryTree_Equal(bool bRecursion)
{
 cout<<"tree equal:/t";

 if (root == NULL)
 {
  return;
 }

 CBinaryTreeNode<T>* tmpRoot = BinaryTree_Copy_Recursion(root);

 bool bEqual = false;

 if (bRecursion)
 {
  bEqual = BinaryTree_Equal_Recursion(root, tmpRoot);
 }
 else
 {
  bEqual = BinaryTree_Equal_Unrecursion(root, tmpRoot);
 }

 BinaryTree_Destroy_Recursion(tmpRoot);

 if (bEqual)
 {
  cout<<" EQUAL"<<endl;
 }
 else
 {
  cout<<" UNEQUAL"<<endl;
 }

}

template<class T> bool CBinaryTree<T>::BinaryTree_Equal_Recursion( CBinaryTreeNode<T> *src, CBinaryTreeNode<T> *dst )
{
 if (src == NULL)
 {
  if (dst != NULL)
  {
   return false;
  }
 }
 else
 {
  if (src->data != dst->data)
  {
   return false;
  }

  BinaryTree_Equal_Recursion(src->left, dst->left);
  BinaryTree_Equal_Recursion(src->right, dst->right);
 }
 return true;
}

template<class T> bool CBinaryTree<T>::BinaryTree_Equal_Unrecursion( CBinaryTreeNode<T> *src, CBinaryTreeNode<T> *dst )
{
 if (src == NULL)
 {
  if (dst != NULL)
  {
   return  false;
  }
  else
  {
   return true;
  }
 }

 CBinaryTreeNode<T>* orgNode = src;
 CBinaryTreeNode<T>* tmpNode = dst;

 CQueue<CBinaryTreeNode<T>*> *orgqueue = new CQueue<CBinaryTreeNode<T>*>(2*nodenum);
 assert(orgqueue!=NULL, "allocate memory failed/n");
 CQueue<CBinaryTreeNode<T>*> *tmpqueue = new CQueue<CBinaryTreeNode<T>*>(2*nodenum);
 assert(tmpqueue!=NULL, "allocate memory failed/n");

 orgqueue->enqueue(orgNode);
 tmpqueue->enqueue(tmpNode);

 while (!orgqueue->empty() && !tmpqueue->empty())
 {
  orgNode = orgqueue->dequeue();
  tmpNode = tmpqueue->dequeue();

  if (orgNode->data != tmpNode->data)
  {
   return false;
  }

  if (orgNode->left != NULL)
  {
   if (tmpNode->left == NULL)
   {
    return false;
   }
   orgqueue->enqueue(orgNode->left);
   tmpqueue->enqueue(tmpNode->left);
  }
  else if (tmpNode->left != NULL)
  {
   return false;
  }

  if (orgNode->right != NULL)
  {
   if (tmpNode->right == NULL)
   {
    return false;
   }
   orgqueue->enqueue(orgNode->right);
   tmpqueue->enqueue(tmpNode->right);
  }
  else if (tmpNode->right != NULL)
  {
   return false;
  }
 }

 if (orgqueue->empty() != tmpqueue->empty())
 {
  return false;
 }

 return true;
}

template<class T> void CBinaryTree<T>::BinaryTree_NodeExchange(bool bRecursion)
{
 cout<<"tree exchange:/t";

 if (root == NULL)
 {
  return;
 }

 if (bRecursion)
 {
   BinaryTree_NodeExchange_Recursion(root);
 }
 else
 {
  BinaryTree_NodeExchange_Unrecursion(root);
 }

 BinaryTree_PreOrder_Recursion(root);

 cout<<endl;

}

template<class T> void CBinaryTree<T>::BinaryTree_NodeExchange_Recursion( CBinaryTreeNode<T> *node )
{

 if ( node == NULL )
 {
  return;
 }
 
 CBinaryTreeNode<T> *tmpNode = node->left;
 node->left = node->right;
 node->right = tmpNode;

 BinaryTree_NodeExchange_Recursion(node->left);
 BinaryTree_NodeExchange_Recursion(node->right);
}

template<class T> void CBinaryTree<T>::BinaryTree_NodeExchange_Unrecursion( CBinaryTreeNode<T> *node )
{
 if (node == NULL)
 {
  return;
 }

 CBinaryTreeNode<T>* tmpNode = node;
 CBinaryTreeNode<T>* tmp = NULL;

 CQueue<CBinaryTreeNode<T>*> *queue = new CQueue<CBinaryTreeNode<T>*>(2*nodenum);
 assert(queue!=NULL, "allocate memory failed/n");

 queue->enqueue(tmpNode);
 while (!queue->empty())
 {
  tmpNode = queue->dequeue();
  tmp = tmpNode->left;
  tmpNode->left = tmpNode->right;
  tmpNode->right = tmp;

  if (tmpNode->left != NULL)
  {
   queue->enqueue(tmpNode->left);
  }
  if (tmpNode->right != NULL)
  {
   queue->enqueue(tmpNode->right);
  }
 }

}

template<class T> void CBinaryTree<T>::PreOrder_Arithmetic_Operations(char *oper)
{
 assert(oper != NULL);

 CStack<char> *stack = new CStack<char>(strlen(oper));
 assert(stack != NULL);

 for (int index=0; index<strlen(oper); index++)
 {
  if (!isOperator(oper[index]))
  {
   stack->push(oper[index] - '0');
  }
  else
  {
   stack->push(oper[index]);
  }
 }

 int lOperand = 0;
 int rOperand = 0;
 char operand;
 int result = 0;
 while (!stack->empty() && stack->size()>1)
 {
  rOperand = stack->pop();
  lOperand = stack->pop();
  operand = stack->pop();
  if (isOperator(operand))
  {
   stack->push(operation(lOperand, rOperand, operand));
  }
  else
  {
   cout<<oper<<" is invalid!"<<endl;
   return;
  }
 }
 cout<<oper<<" = "<<(int)(stack->pop())<<endl;
}

template<class T> void CBinaryTree<T>::InOrder_Arithmetic_Operations(char *oper)
{
 assert(oper != NULL);

 CStack<char> *stack1 = new CStack<char>(strlen(oper));
 assert(stack1 != NULL);

 CQueue<char> *queue = new CQueue<char>(strlen(oper));
 assert(queue != NULL);

 for (int index=0; index<strlen(oper); index++)
 {
  if (oper[index] == '(')
  {
   stack1->push(oper[index]);
  }
  else if (oper[index] == ')')
  {
   while (!stack1->empty() && stack1->peek()!='(')
   {
    queue->enqueue(stack1->pop());
   }
   stack1->pop();
  }
  else if (!isOperator(oper[index]))
  {
   queue->enqueue(oper[index]-'0');
  }
  else
  {
   if (!stack1->empty() && stack1->peek()!='(')
   {
    char operand = stack1->peek();
    if (priority(operand) >= priority(oper[index]))
    {
     queue->enqueue(stack1->pop());
    }

   }
   stack1->push(oper[index]);
  }
 }

 while (!stack1->empty())
 {
  queue->enqueue(stack1->pop());
 }

 CStack<char> *stack2 = new CStack<char>(strlen(oper));
 assert(stack2 != NULL);

 while(!queue->empty())
 {
  char tmp = queue->dequeue();
  if (!isOperator(tmp))
  {
   stack2->push(tmp);
  }
  else
  {
   int roperand = stack2->pop();
   int loperand = stack2->pop();
   stack2->push(operation(loperand, roperand, tmp));
  }
 }
 cout<<oper<<" = "<<(int)(stack2->pop())<<endl;
}

template<class T> void CBinaryTree<T>::PostOrder_Arithmetic_Operations(char *oper)
{
 assert(oper != NULL);

 CStack<char> *stack = new CStack<char>(strlen(oper));
 assert(stack != NULL);

 int lOperand = 0;
 int rOperand = 0;
 char operand;

 for (int index=0; index<strlen(oper); index++)
 {
  operand = oper[index];
  if (isOperator(operand))
  {
   rOperand = stack->pop();
   lOperand = stack->pop();
   stack->push(operation(lOperand, rOperand, operand));
  }
  else
  {
   stack->push(oper[index]-'0');
  }
 }
 cout<<oper<<" = "<<(int)(stack->pop())<<endl;
}

template<class T> bool CBinaryTree<T>::isOperator(char oper)
{
 if (oper == '+' || oper == '-' || oper == '*' || oper == '/')
 {
  return true;
 }
 else
 {
  return false;
 }
}

template<class T> int CBinaryTree<T>::operation(int loper, int roper, char oper)
{
 switch(oper)
 {
 case '+':
  return loper + roper;
  break;
 case '-':
  return loper - roper;
  break;
 case '*':
  return loper*roper;
  break;
 case '/':
  return loper/roper;
  break;
 default:
  return -1;
  break;
 }
}

template<class T> int CBinaryTree<T>::priority(char oper)
{
 switch(oper)
 {
 case '+':
 case '-':
  return 1;
  break;
 case '*':
 case '/':
  return 2;
  break;
 default:
  return -1;
  break;
 }
}