二叉树 常见操作

template<class _T>
struct _TNode
{
_T data;
_TNode* pLeft;
_TNode* pRight;
_TNode* pParent;
_TNode()
{
pLeft = pRight = pParent = NULL;
}
};

template<typename _T>
class CBinaryTree
{
public:
CBinaryTree()
{
m_pRoot = NULL;
}
~CBinaryTree()
{
Clear();
}
void CreateTree(const _T& t);
void PreOrder() const;
void InOrder() const;
void PostOrder() const;
void LevelOrder() const;

void Layout() const;
void Layout2() const;

int Height() const;
private:
void CreateTree(_TNode<_T>** ppNode,const _T& t);

CBinaryTree(const CBinaryTree& tree);
CBinaryTree& operator = (const CBinaryTree& tree);

void Clear();
void Clear(_TNode<_T>* pNode);

int Height(const _TNode<_T>* pNode) const;

void inline Visit(const _TNode<_T>* PNode) const;

// 递归
void PreOrder(const _TNode<_T>* pNode) const;
void InOrder(const _TNode<_T>* pNode) const;
void PostOrder(const _TNode<_T>* pNode) const;

//非递归
void PreOrderNoRecursion(const _TNode<_T>* pNode) const;
void InOrderNoRecursion(const _TNode<_T>* pNode) const;
void PostOrderNoRecursion(const _TNode<_T>* pNode) const;
void LevelOrderNoRecursion(const _TNode<_T>* pNode) const;

_TNode<_T>* m_pRoot;
};

template<typename _T>
void CBinaryTree<_T>::Visit(const _TNode<_T>* pNode) const
{
if (pNode != NULL)
{
cout << pNode->data << endl;
}
}

template<typename _T>
void CBinaryTree<_T>::Clear(_TNode<_T>* pNode)
{
if (pNode != NULL)
{
_TNode<_T>* pLeft = pNode->pLeft;
_TNode<_T>* pRight = pNode->pRight;

delete pNode;
Clear(pLeft);
Clear(pRight);
}
}

template<typename _T>
void CBinaryTree<_T>::Clear()
{
stack<_TNode<_T>*,vector<_TNode<_T>*>> TStack;

if (m_pRoot != NULL)
TStack.push(m_pRoot);

_TNode<_T>* pCur = TStack.top();
while (!TStack.empty())
{
TStack.pop();
if (pCur != NULL)
{
TStack.push(pCur->pRight);
TStack.push(pCur->pLeft);

delete pCur;
pCur = NULL;
}
if (!TStack.empty())
{
pCur = TStack.top();
}
}
}

template<typename _T>
void CBinaryTree<_T>::CreateTree(const _T& t)
{
return CreateTree(&m_pRoot,t);
}

template<typename _T>
void CBinaryTree<_T>::CreateTree(_TNode<_T>** ppNode,const _T& t)
{
if (ppNode == NULL)
{
cout << "Invalid Parameter" << endl;
}

if (*ppNode == NULL)
{
*ppNode = new _TNode<_T>;
(*ppNode)->data = t;
}
else
{
if ((*ppNode)->data > t)
{
CreateTree(&(*ppNode)->pLeft,t);
}
else
{
CreateTree(&(*ppNode)->pRight,t);
}
}
}

template<typename _T>
void CBinaryTree<_T>::PreOrder() const
{
PreOrderNoRecursion(m_pRoot);
return PreOrder(m_pRoot);
}

template<typename _T>
void CBinaryTree<_T>::PreOrder(const _TNode<_T>* pNode) const
{
if (pNode == NULL)
return;

Visit(pNode);
PreOrder(pNode->pLeft);
PreOrder(pNode->pRight);
}

template<typename _T>
void CBinaryTree<_T>::PreOrderNoRecursion(const _TNode<_T>* pNode) const
{
stack<const _TNode<_T>*> TStack;

#if 0
if (pNode != NULL)
{
const _TNode<_T>* pCur = pNode;
while (pCur != NULL)
{
Visit(pCur);
if (pCur->pRight != NULL)
{
TStack.push(pCur->pRight);
}

if (pCur->pLeft != NULL)
{
TStack.push(pCur->pLeft);
}

if (!TStack.empty())
{
pCur = TStack.top();
TStack.pop();
}
else
{
pCur = NULL;
}
}
}
#else
const _TNode<_T>* pCur = pNode;
while (!TStack.empty() || (pCur != NULL))
{
while (pCur != NULL)
{
Visit(pCur);
TStack.push(pCur);
pCur = pCur->pLeft;
}
if (!TStack.empty())
{
pCur = TStack.top();
TStack.pop();
pCur = pCur->pRight;
}
}
#endif
}

template<typename _T>
void CBinaryTree<_T>::InOrder() const
{
InOrderNoRecursion(m_pRoot);
return InOrder(m_pRoot);
}

template<typename _T>
void CBinaryTree<_T>::InOrder(const _TNode<_T>* pNode) const
{
if (pNode == NULL)
return;
InOrder(pNode->pLeft);
Visit(pNode);
InOrder(pNode->pRight);
}

template<typename _T>
void CBinaryTree<_T>::InOrderNoRecursion(const _TNode<_T>* pNode) const
{
const _TNode<_T>* pCur = NULL;
stack<const _TNode<_T>*> TStack;

pCur = pNode;
while (!TStack.empty() || (pCur != NULL))
{
while (pCur != NULL)
{
TStack.push(pCur);
pCur = pCur->pLeft;
}

if (!TStack.empty())
{
pCur = TStack.top();
TStack.pop();
Visit(pCur);
pCur = pCur->pRight;
}
}
}

template<typename _T>
void CBinaryTree<_T>::PostOrder() const
{
PostOrderNoRecursion(m_pRoot);
return PostOrder(m_pRoot);
}

template<typename _T>
void CBinaryTree<_T>::PostOrder(const _TNode<_T>* pNode) const
{
if (pNode == NULL)
return;

PostOrder(pNode->pLeft);
PostOrder(pNode->pRight);
Visit(pNode);
}

template<typename _T>
void CBinaryTree<_T>::PostOrderNoRecursion(const _TNode<_T>* pNode) const
{
const _TNode<_T>* pCur = pNode;
const _TNode<_T>* pPre = NULL;
stack<const _TNode<_T>*> TStack;

while (!TStack.empty() || (pCur != NULL))
{
if (pCur != NULL)
{
TStack.push(pCur);
pCur = pCur->pLeft;
}
else
{
pCur = TStack.top();
if ((pCur->pRight != NULL) && (pPre != pCur->pRight))
{
pCur = pCur->pRight;
}
else
{
pPre = pCur;
Visit(pCur);
TStack.pop();
pCur = NULL;
}
}
}
}

template<typename _T>
void CBinaryTree<_T>::LevelOrder() const
{
return LevelOrderNoRecursion(m_pRoot);
}

template<typename _T>
void CBinaryTree<_T>::LevelOrderNoRecursion(const _TNode<_T>* pNode) const
{
queue<const _TNode<_T>*> TQueue;
const _TNode<_T>* pCur = pNode;

while (pCur != NULL)
{
Visit(pCur);
if (pCur->pLeft != NULL)
{
TQueue.push(pCur->pLeft);
}
if (pCur->pRight != NULL)
{
TQueue.push(pCur->pRight);
}

if (!TQueue.empty())
{
pCur = TQueue.front();
TQueue.pop();
}
else
{
pCur = NULL;
}
}
}

template<typename _T>
void CBinaryTree<_T>::Layout() const
{
stack<pair<const _TNode<_T>*,int>> TStack2;
stack<const _TNode<_T>*> TStack;
const _TNode<_T>* pCur = m_pRoot;
int index = 0;

while ( pCur != NULL || !TStack.empty())
{
while (pCur != NULL)
{
TStack.push(pCur);
TStack2.push(make_pair(pCur,index));
pCur = pCur->pLeft;
index++;
}
if (!TStack.empty())
{
pCur = TStack.top();

pair<const _TNode<_T>*,int> node = TStack2.top();

for (int i = 0; i < node.second; ++i)
{
cout << '/t' ;
}
cout << node.first->data << endl;

TStack.pop();
TStack2.pop();
pCur = pCur->pRight;
if (pCur == NULL)
index--;
}
}
}

template<typename _T>
void CBinaryTree<_T>::Layout2() const
{
queue<const _TNode<_T>*> TQueue;
queue<pair<const _TNode<_T>*,int>> TQueue2;
const _TNode<_T>* pCur = m_pRoot;
int index = 0;

while( pCur != NULL)
{
for (int i = 0; i < 12 - index; ++i)
cout << '/t';
cout << pCur->data << endl;

TQueue.push(pCur->pLeft);
TQueue.push(pCur->pRight);
++index;
pCur = TQueue.front();
TQueue.pop();
}
}

template<typename _T>
int CBinaryTree<_T>::Height() const
{
return Height(m_pRoot);
}

template<typename _T>
int CBinaryTree<_T>::Height(const _TNode<_T>* pNode) const
{
if (pNode == NULL)
return 0;

int left = 0;
int right = 0;
left = Height(pNode->pLeft);
right = Height(pNode->pRight);

return left>right?(left+1):(right+1);
}