二叉树的实现

#include<stack>
#include<queue>
#include<iostream>
using namespace std;
template<class T>
struct BinaryTreeNode
{
 　　T _data;
 　　BinaryTreeNode<T>* _left;
 　　BinaryTreeNode<T>* _right;
 　　BinaryTreeNode() : _left(NULL), _right(NULL)
 　　{}
 　　BinaryTreeNode(const T&x) :_data(x), _left(NULL), _right(NULL)
 　　{}
};

template<class T>
class BinaryTree
{
public:
 　　BinaryTree() :_root(NULL)
 　　{}
 　　BinaryTree(const T*a, size_t size)
 　　{
 　　　　 size_t index = 0;
 　　　　 _root = _CreateTree(a, size, index);  //创建二叉树
 　　}
 　　BinaryTree(const BinaryTree<T>& t)
 　　{
 　　　　 _root=_Copy(t._root);
　　 }

　　void PrevOrder()  //前序遍历（递归）

　　{   

　　　　_PrevOrder(_root);  

　　} 

 　　void PrevOrder_NonR()   //前序遍历（非递归）

　　{   

　　　　_PrevOrder_NonR(_root);

　　}

　　void InOrder()   //中序遍历（递归）
 　 {　　
 　　　　 _InOrder(_root);
　　}
　 void InOrder_NonR() 　　 //中序遍历（非递归）
 　{
 　　　　 _InOrder_NonR(_root);
 　 }

　void PostOrder()　 //后序遍历（递归）

   {
          _PostOrder(_root);
   }
  void PostOrder_NonR() //后序遍历（非递归）
  {
  　　_PostOrder_NonR(_root);
  }
  void LevelOrder()  //层次遍历
  {
  　　_LevelOrder(_root);
  }

int size() //二叉树大小
 {
 　　  return _size(_root);
 }
 int Depth()   //二叉树深度
 {
  　　return _Depth(_root);
 } 
 int GetLeafNum()  //叶子结点的个数
 {
 　　 return _GetLeafNum(_root);
 }
 BinaryTreeNode<T>* Find(const T&x)  //在二叉树查找某个数
 {
 　　 return _Find(_root,x);
 }
 ~BinaryTree()
 {
  　　_Destory(_root);
  　　_root = NULL;
 }

protected:
 BinaryTreeNode<T>* _CreateTree(const T*a, size_t size, size_t &index)  
 {
 　　 BinaryTreeNode<T>* root = NULL;
  　　if (index < size&&a[index] != '#')
  　　{
  　　　　 root = new BinaryTreeNode<T>(a[index]);
  　　　　 root->_left = _CreateTree(a, size, ++index);
  　　　　 root->_right = _CreateTree(a, size, ++index);
  　　}
 　　 return root;

}
 void _Destory(BinaryTreeNode<T>*& root)
 {
  　　if (root == NULL)
  　　 return;
   　　if (root->_left == NULL&&root->_right == NULL)
  　　{
  　　　　 delete root;
   　　　　root = NULL;
   　　　　return;
  　　}
  　　_Destory(root->_left);
  　　_Destory(root->_right);
  　　delete root;
 }

void _PrevOrder(BinaryTreeNode<T> *root)
 {
  　　if (root == NULL)
 　　 {
 　　　　  return;
  　　}
  　　else
  　　{
   　　　　cout << root->_data << " ";
   　　　　_PrevOrder(root->_left);
   　　　　_PrevOrder(root->_right);
  　　}
 }

void _PrevOrder_NonR(BinaryTreeNode<T>* root)  

{   

　　stack<BinaryTreeNode<T>*> s;   

　　if (root);   

　　s.push(root);   

　　while (!s.empty())   

　　{    

　　　　BinaryTreeNode<T>* top = s.top();    

　　　　cout << top->_data << " ";    

　　　　s.pop();

  　　　 if (top->_right)    

　　　　{     

　　　　　　 s.push(top->_right);    

　　　　}    

　　　　if (top->_left)   

 　　　　{   

 　　　　　　 s.push(top->_left);   

 　　　　}   

　　}

 　　cout << endl;  

}

void _InOrder(BinaryTreeNode<T> *root)
 {
  　　if (root == NULL)
 　　 {
  　　　　 return;
  　　}
  　　else
  　　{
  　　　　 _InOrder(root->_left);
   　　　　cout << root->_data << " ";
   　　　　_InOrder(root->_right);
  　　}
 }

void _InOrder_NonR(BinaryTreeNode<T> *root)
 {
  　　stack<BinaryTreeNode<T>*> s;
 　　 BinaryTreeNode<T>* cur = root;
  　　while (!s.empty()||cur)
  　　{
  　　　　 while (cur)
   　　　　{
  　　　　　　  s.push(cur);
   　　　　　　 cur = cur->_left;
   　　　　}
  　　　　 if(!s.empty())
   　　　　{
   　　　　　　 BinaryTreeNode<T>* top = s.top();
   　　　　　　 cout << top->_data << " ";
    　　　　　　s.pop();
    　　　　　　cur = top->_right;
  　　　　 }
  　　}
 }

void _PostOrder(BinaryTreeNode<T> *root) 

 {  

　　　　 if (root == NULL)   

　　　　{    

　　　　　　　　return;   

　　　　}   

　　　　else   

　　　　{    

　　　　　　_PostOrder(root->_left);   

 　　　　　　_PostOrder(root->_right);   

　　　　　　 cout << root->_data << " ";

  　　　　}  

}

void _PostOrder_NonR(BinaryTreeNode<T> *root)  

{

 　　　　 stack<BinaryTreeNode<T>*> s;  

　　　　 BinaryTreeNode<T>* cur = root;  

 　　　　BinaryTreeNode<T>* prevVisted = NULL;   

　　　　while (!s.empty() || cur)   

　　　　{    

　　　　　　while (cur)    

　　　　　　{     

　　　　　　　　s.push(cur);     

　　　　　　　　cur = cur->_left;   

 　　　　　　}    

　　　　　　BinaryTreeNode<T>* top = s.top();   

　　　　　　 if (top->_right==NULL||top->_right==prevVisted)    

　　　　　　{     

　　　　　　　　cout << top->_data << " ";     

　　　　　　　　prevVisted = top;     

　　　　　　　　s.pop();     

　　　　　　}    

　　　　　　else    

　　　　　　{     

　　　　　　　　cur = top->_right;   

 　　　　　　}   

　　　　}  

}

int _size(BinaryTreeNode<T>* root)
 {
 　　　　 if (root == NULL)
 　　　    return 0;
 　　　　 return _size(root->_left) + _size(root->_right) + 1;
 }
 int _Depth(BinaryTreeNode<T>* root)
 {
  　　　　if (root == NULL)
   　　　　return 0;
  　　　　int LeftDepth = _Depth(root->_left);
 　　　　 int RightDepth = _Depth(root->_left);
 　　　　 return  LeftDepth>RightDepth ? LeftDepth+1 : RightDepth + 1;
 }

int _GetLeafNum(BinaryTreeNode<T>* root)
 {
 　　　　 if (root == NULL)
  　　　   return 0;
  　　　　if (root->_left == NULL&&root->_right == NULL)
 　　　　  return 1;
 　　　　 else
  　　　 return _GetLeafNum(root->_left) + _GetLeafNum(root->_right);
 }
 BinaryTreeNode<T> *_Find(BinaryTreeNode<T>* root, const T&x)
 {
  　　　　if (root == NULL)
  　　　   return NULL;
 　　　　 else if (root->_data == x)
 　　　　 {
 　　　　　　  return root;
 　　　　 }
 　　　　 else
　　　　  {
　　　　　　   BinaryTreeNode<T> *ret= _Find(root->_left, x);
　　　　　　   if (ret)
　　　　　　   return ret;
　　　　 　　  else
　　　　 　　  {
　　　　　　　　    return _Find(root->_right,x);
 　　　　  　　}
  　　　　}
 }

void _LevelOrder(BinaryTreeNode<T>* root)
 {
  　　queue<BinaryTreeNode<T>*> q;
  　　if (root == NULL)
  　　 return;
 　　 q.push(root);
 　　 while (!q.empty())
  　　{
 　　　　　  BinaryTreeNode<T> *front = q.front();
  　　　　　 q.pop();
　　　　　   cout << front->_data << " ";
　　　　　   if (front->_left)
  　　　　   {
  　　　　　　　　  q.push(front->_left);
  　　　　   }
  　　　　   if (front->_right)
 　　　　    {
 　　　　　　　　   q.push(front->_right);
 　　　　    }
 　　 }
  　　cout<< endl;
 }
 BinaryTreeNode<T>* _Copy(BinaryTreeNode<T>* root)
 {
 　　　　 if (root == NULL)
  　　　　 return NULL; 
  　　　　BinaryTreeNode<T>* newRoot=new BinaryTreeNode<T>(root->_data);
  　　　　newRoot->_left=_Copy(root->_left);
  　　　　newRoot->_right=_Copy(root->_right);
  　　　　return newRoot;
 }

BinaryTreeNode<T>& operator=(BinaryTreeNode<T>*& t)  

{   

　　　　if (this != &t)   

　　　　{    

　　　　　　this->_Destory(_root);    

　　　　　　_root = _Copy(t._root);   

　　　　}    

　　　　return *this;  

}  

/*BinaryTreeNode<T>& operator=(BinaryTreeNode<T> t)  

{   

　　　　swap(_root, t._root);   

　　　　return *this;  

}*/

protected:  BinaryTreeNode<T> *_root; 

};

int main() 

{

　　　　int a[10] = { 1, 2, 3, '#', '#', 4, '#','#', 5, 6 }; 

 　　　  BinaryTree<int> t(a, 10);  

　　　　BinaryTree<int> t1(t);  

　　　　BinaryTree<int> t2; 

　　　　 t2 = t;  

　　　　cout << t.size() << endl;  

　　　　cout << t.Depth() << endl;  

　　　　cout << t1.size() << endl;  

　　　　cout << t1.Depth() << endl;  

　　　　cout << t2.size() << endl;  

　　　　cout << t.Find(3)->_data << endl;  

　　　　cout << t.Find(5)->_data << endl;  

　　　　cout << t.Find(12) << endl;  

　　　　cout<<t.GetLeafNum();  

　　　　cout<< endl;    

　　　　t.InOrder();  

　　　　cout << endl;  

　　　　t.InOrder_NonR();  

　　　　cout << endl;  

　　　　t.PostOrder(); 

 　　　　cout << endl; 

　　　　 t.PostOrder_NonR();  

　　　　cout << endl; 

　　　　 t.PrevOrder();  

　　　　cout << endl;  

　　　　t.PrevOrder_NonR();  

　　　　cout << endl;  

　　　　t.LevelOrder();

　　　　system("pause");  

　　　　return 0; 

}