唯一需要注意的就是里面几种遍历的非递归实现,借助了队列和栈来进行实现。
下面是完整的代码:
#pragma once
#include<iostream>
#include<stack>
#include<queue>
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);
}
//下面使用到了&index,但是不能对一个常量进行引用,所以要把index定义为一个变量
BinaryTree(const BinaryTree<T>& bt)
{
_pRoot = CopyBinaryTree(bt._pRoot);
}
BinaryTree<T>& operator=(const BinaryTree<T>& bt)
{
if (this != &bt)
{
_DestroyBinaryTree(_pRoot);
_pRoot = CopyBirnaryTree(bt._pRoot);
}
return *this;
}
~BinaryTree()
{
_DestroyBinaryTree(_pRoot);
}
void PreOrder()
{
cout << "PreOrder:" << endl;
_PreOrder(_pRoot);
cout << endl;
}
void PostOrder()
{
cout << "PostOrder:" << endl;
_PostOrder(_pRoot);
cout << endl;
}
void MidOrder()
{
cout << "MidOrder:" << endl;
_MidOrder(_pRoot);
cout << endl;
}
Node* Find(const T& value)
{
return _Find()
}
void PostOrder_Nor()//非递归实现后序
{
cout << "PostOrder_Nor:" << endl;
if (NULL == _pRoot)
return;
stack<Node*> s;
Node* pCur = _pRoot;
Node* pPre = NULL;
while (pCur || !s.empty())
{
while (pCur)
{
s.push(pCur);
pCur = pCur->_pLeft;
}
Node* pTop = s.top();
if (NULL == pTop->_pRight || pTop->_pRight == pPre)
{
cout << pTop->_value << " ";
pPre = pTop;
s.pop();
}
else
pCur = pTop->_pRight;
}
}
void MidOrder_Nor()//非递归实现中序
{
cout << "MidOrder_Nor:" << endl;
if (NULL == _pRoot)
return;
stack<Node*> s;
Node *pCur = _pRoot;
while (!s.empty() || pCur)
{
while (pCur)
{
s.push(pCur);
pCur = pCur->_pLeft;
}
if (NULL == pCur && !s.empty())
{
pCur = s.top();
cout << pCur->_value << " ";
s.pop();
pCur = pCur->_pRight;
}
}
}
void PreOrder_Nor()//非递归实现前序
{
if (NULL == _pRoot)
return;
stack<Node*> s;
s.push(_pRoot);
while (!s.empty())
{
Node* pTop = s.top();
cout << pTop->_value << " ";
s.pop();
if (pTop->_pRight)
s.push(pTop->_pRight);
if (pTop->_pLeft)
s.push(pTop->_pLeft);
}
}
bool IsComPleteBinaryTree()//利用层序遍历判断是否为完全二叉树
{
if (NULL == _pRoot)
return true;
bool flag = false;
queue<Node*> q;
Node* pCur = _pRoot;
q.push(_pRoot);
while (!q.empty())
{
Node* pCur = q.front();
if (flag)
{
if (pCur->_pLeft || pCur->_pRight)
return false;
}
else
{
if (pCur->_pLeft&&pCur->_pRight)
{
q.push(pCur->_pLeft);
q.push(pCur->_pRight);
}
else if (pCur->_pLeft)
{
q.push(pCur->_pLeft);
flag = true;
}
else if (pCur->_pRight)
{
q.push(pCur->_pRight);
flag = false;
}
else
flag = true;
}
q.pop();
}
return true;
}
private:
void _CreateBinaryTree(Node* &pRoot, const T array[],size_t size, size_t& index,const T& invalid)
{
if (index < size && invalid != array[index])//注意条件的判断次序
{
//创建根节点
pRoot = new Node(array[index]);
//创建左子数
_CreateBinaryTree(pRoot->_pLeft, array, size, ++index,invalid);//如果用index+1,初始的index并没有发生变化
//创建右子数
_CreateBinaryTree(pRoot->_pRight, array, size, ++index, invalid);
}
}
Node* CopyBirnaryTree(Node* pRoot)
{
Node* pNewNode = NULL;
//拷贝根节点
if (pRoot)
{
pNewNode = new Node(pRoot->_value);
//拷贝左子树
pNewNode->_pLeft = CopyBirnaryTree(pRoot->_pLeft);
//拷贝右子树
pNewNode->_pRight = CopyBirnaryTree(pRoot->_pRight);
}
return pNewNode;
}
void _DestroyBinaryTree(Node* &pRoot)
{
if (pRoot)
{
_DestroyBinaryTree(pRoot->_pLeft);
_DestroyBinaryTree(pRoot->_pRight);
delete pRoot;
pRoot = NULL;
}
}
void _PreOrder(Node* pRoot)
{
if (pRoot)
{
cout << pRoot->_value << " ";
_PreOrder(pRoot->_pLeft);
_PreOrder(pRoot->_pRight);
}
}
void _PostOrder(Node* pRoot)
{
if (pRoot)
{
_PreOrder(pRoot->_pLeft);
_PreOrder(pRoot->_pRight);
cout << _pRoot->_value << " ";
}
}
void _MidOrder(Node* pRoot)
{
if (pRoot)
{
_PreOrder(pRoot->_pLeft);
cout << _pRoot->_value << " ";
_PreOrder(pRoot->_pRight);
}
}
private:
Node* _pRoot;//根节点
};
int main()
{
char* ptr = "124###35##6";
BinaryTree<char> bt(ptr, strlen(ptr), '#');
//BinaryTree<char> bt1(bt);
//bt.PostOrder();
bt.MidOrder_Nor();
/*bt.MidOrder();
BinaryTree<char> bt2;
bt2 = bt;
bt2.PreOrder();
bt2.PostOrder_Nor();
bt2.IsComPleteBinaryTree();*/
return 0;
}