二叉树的递归遍历

#include<iostream>
#include<cassert>
#include<cstdlib>
using namespace std;
template<class T>
struct TreeNode
{
 T _data;
 TreeNode<T> *left;
 TreeNode<T> *right;
};
template<class T>
class Tree
{
 typedef TreeNode<T> Node;
public:
 Tree()
  :_root(NULL)
 {}
 Tree(T *a,size_t size, const T& invalid)
 {
  size_t index=0;
  _root=CreatNode(a,size,index,invalid);
 }
    
 Tree<T>& operator=(const Tree<T>& t)
 {
  if(this!=&t)
     std::swap(_root,t._root );
  return *this;  
 }
 
 void _PrevOrder(Node* root)
 {
  cout<<root->_data <<' ';
     _PrevOrder(root->left);
  _PrevOrder(root->right);
 }
 void _InOrder(Node* root)
 {
  assert(root);
  _InOrder(root->left);
  cout<<root->_data<<' ';
     _InOrder(root->right);
 }
 void _PostOrder(Node* root)
 {
  assert(root);
  _PostOrder(root->left);
  _PostOrder(root->right);
  cout<<root->_data<<' ';
 }
 void PostOrder()
 {
    _PostOrder(_root);
    cout<<endl;
 }
 void PrevOrder()
 {
  _PrevOrder(_root);
  cout<<endl;
 
 }
 void InOrder()
 {
  _InOrder(_root);
 
 }
 protected:
 Node* CreatNode(T* a,size_t size,size_t& index,const T& invalid)
 {
  assert(a);
  Node* root=new Node(NULL);
  if((index<=size)&&a[index]!=invalid)
  {
   root->_data=a[index];
   root->left=CreatNode(a,size,++index,invalid);
   root->right=CreatNode(a,size,++index,invalid);

  }
     return root;
 }
 
 
private:
 Node* _root;
};
void test()
{
 int a1[10]={1,2,3,'#','#',4,'#','#',5,6};
 Tree<int> t1 (a1,10,'#');
 t1.InOrder();
 

}
int main()
{
 test();
 system("pause");
 return 0;

}