递归实现二叉树

这是一个比较全面的二叉树的实现，包括建立，遍历，大小，深度，删除等操作的实现。
利用递归，可以很简单很快捷的实现对二叉树的操作

BinaryTree.hpp

#pragma once
#include<iostream>
using namespace std;
#include<queue>
template<class T>
struct BinaryTreeNode{                    //结点的结构体
 char _value;
 BinaryTreeNode* _left;
 BinaryTreeNode* _right;
 BinaryTreeNode(char value)
  :_value(value)
  ,_left(NULL)
  , _right(NULL)
 {}
};
template<class T>
class BinaryTree{
public:
 BinaryTree()         //空二叉树构造函数
  :_root(NULL)
 {}
 BinaryTree(const char* str):_root(NULL){       //非空二叉树构造函数
  _CreateBinaryTree(_root,str);
 }
 BinaryTree(const BinaryTree& t){               //拷贝构造函数
  _root = _Copy(t._root);
 }
 BinaryTree &operator =(const BinaryTree& t){   //重载函数
  swap(_root, t._root);
  return *this;
 }
 ~BinaryTree(){          //析构函数
  _Delete(_root);
 }
 void PrevOrder(){          //先序遍历
  _PrevOrder(_root);
  cout << endl;
 }
 void InOrder(){                                //中序遍历
  _InOrder(_root);
  cout << endl;
 }
 void PostOrder(){                              //后序遍历
  _PostOrder(_root);
  cout << endl;
 }
 void LevelOrder(){                             //层遍历
  _LevelOrder(_root);
  cout << endl;
 }
 int Size(){                                    //二叉树值结点个数
  return _Size(_root);
 }
 int Depth(){          //二叉树的深度
  return _Depth(_root);
 }
protected:
 void _CreateBinaryTree(BinaryTreeNode<T>*& root, const char*& str){     //创建二叉树
  if (*str != '#' && *str != '\0'){
   root = new BinaryTreeNode<T>(*str);
   _CreateBinaryTree(root->_left, ++str);
   _CreateBinaryTree(root->_right, ++str);
  }
 }
 BinaryTreeNode<T>* _Copy(BinaryTreeNode<T>* root){                       //拷贝
  BinaryTreeNode<T>* _new = NULL;
  if (root){
   _new = new BinaryTreeNode<T>(root->_value);
   while (root){
    _new->_left = _Copy(root->_left);
    _new->_right = _Copy(root->_right);
    return _new;
   }
  }
  return _new;
 }
 BinaryTreeNode<T>* _Delete(BinaryTreeNode<T>* root){                   //释放
  while (root){
   _Delete(root->_left);
   _Delete(root->_right);
   delete root;
   return root;
  }
  return root;
 }
 void _PrevOrder(BinaryTreeNode<T>* root){                        //先序
  if (root){
   cout << root->_value << " ";
   _PrevOrder(root->_left);
   _PrevOrder(root->_right);
  }
 }
 void _InOrder(BinaryTreeNode<T>* root){                          //中序
  if (root){
   if (root->_left == NULL && root->_right == NULL)
    cout << root->_value << " ";
   else{
    _InOrder(root->_left);
    cout << root->_value << " ";
    _InOrder(root->_right);
   }
  }
 }
 
 void _PostOrder(BinaryTreeNode<T>* root){                       //后序
  if (root){
   if (root->_left == NULL && root->_right == NULL)
    cout << root->_value << " ";
   else{
    _PostOrder(root->_left);
    _PostOrder(root->_right);
    cout << root->_value << " ";
   }
  }
 }
 void _LevelOrder(BinaryTreeNode<T>* root){                        //层
  queue<BinaryTreeNode<T>*> q;
  q.push(root);
  while (root){
   cout << root->_value << " ";
   if (!q.empty()){
    BinaryTreeNode<T>* front = q.front();
    q.pop();
    q.push(front->_left);
    q.push(front->_right);
   }
   root = q.front();
  }
 }
 int _Size(BinaryTreeNode<T>* root){                          //大小
  int count = 0;
  if (root){
   count += _Size(root->_left);
   count += _Size(root->_right);
  }
  if (root)
   return count + 1;
  else
   return count;
 }
 int _Depth(BinaryTreeNode<T>* root){                        //深度
  int left_depth = 0;
  int right_depth = 0;
  if (root){
   left_depth = _Depth(root->_left);
   right_depth = _Depth(root->_right);
   return (left_depth > right_depth) ? left_depth + 1 : right_depth + 1;
  }
  else
   return 0;
 }
private:
 BinaryTreeNode<T>* _root;
};