二叉树的实现

此二叉树主要用孩子表示法，递归创建二叉树。

#include <iostream>
#include <string.h>
#include <queue>
#include <assert.h>
using namespace std;
template<class T>
struct BinaryTreeNode
{
	BinaryTreeNode(const T& value)
		: _value(value)
		, _pLeft(NULL)
		, _pRight(NULL)
	{}

	T _value;
	BinaryTreeNode<T>* _pLeft;   // 左孩子
	BinaryTreeNode<T>* _pRight;  // 右孩子
};


template<class T>
class BinaryTree
{
	typedef BinaryTreeNode<T> Node;
public:
	BinaryTree()
		: _pRoot(NULL)
	{}

	BinaryTree(const T array[], size_t size, const T& invalid)
	{
		size_t index = 0;
		//递归创建一个二叉树
		_CreateBinaryTree(_pRoot, array, size, index, invalid);
	}

	BinaryTree(const BinaryTree<T>& bt)
	{
		_pRoot = _CopyBirnaryTree(bt._pRoot);
	}

	BinaryTree<T>& operator=(const BinaryTree<T>& bt)
	{
		if (bt._pRoot != _pRoot)
		{
			BinaryTree<T> temp(bt);
			_DestroyBinaryTree(_pRoot);
			_pRoot = temp._pRoot;
		}
		return *this;
	}

	~BinaryTree()
	{
		_DestroyBinaryTree(_pRoot);
	}


private:
	// 递归创建一个二叉树
	Node* _CreateBinaryTree(Node* &pRoot, const T array[], size_t size, size_t& index, const T& invalid)
	{
		Node* tmp = NULL;
		if (index < size&&array[index] != invalid)
		{
			tmp = new Node(array[index]);
			pRoot = tmp;
			_CreateBinaryTree(pRoot->_pLeft, array, size, ++index, invalid);
			_CreateBinaryTree(pRoot->_pRight, array, size, ++index, invalid);
		}
		return tmp;
	}

	// pRoot-->被拷贝树的根节点
	Node* _CopyBirnaryTree(Node* pRoot)
	{
		Node* pCur = NULL;
		if (pRoot != NULL)
		{
			pCur = new Node(pRoot->_value);
			pCur->_value = pRoot->_value;
			pCur->_pLeft = _CopyBirnaryTree(pRoot->_pLeft);
			pCur->_pRight = _CopyBirnaryTree(pRoot->_pRight);
		}
		return pCur;
	}

	void _DestroyBinaryTree(Node*& pRoot)
	{
		if (pRoot != NULL)
		{
			_DestroyBinaryTree(pRoot->_pRight);
			_DestroyBinaryTree(pRoot->_pLeft);
			delete pRoot;
			pRoot = NULL;
		}
	}

private:
	Node* _pRoot;   // 指向树的根节点
	T _invalid;
};