此二叉树主要用孩子表示法,递归创建二叉树。
#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;
};