二叉树基本操作递归和非递归方法

#ifndef _BSTREE_H_
#define _BSTREE_H_

#include <stack>
#include <queue>
#include <iostream>
using namespace std;

//二叉树节点类型定义
template<class T>
class BSTreeNode{
public:
	BSTreeNode<T>(const T& data, BSTreeNode<T>* pLeft = NULL, BSTreeNode<T>* pRight = NULL){
		m_Data = data;
		m_pLeft = pLeft;
		m_pRight = pRight;
	}

	T				m_Data;
	BSTreeNode<T>*	m_pLeft;
	BSTreeNode<T>*	m_pRight;
};


//递归算法前序遍历
template<class T>
void PreOrderTraversal(BSTreeNode<T>* pRoot){
	if (pRoot == NULL){
		return;
	}
	cout << pRoot->m_Data << " ";
	PreOrderTraversal(pRoot->m_pLeft);
	PreOrderTraversal(pRoot->m_pRight);
}

//递归算法中序遍历
template<class T>
void InOrderTraversal(BSTreeNode<T>* pRoot){
	if (pRoot == NULL){
		return;
	}
	InOrderTraversal(pRoot->m_pLeft);
	cout << pRoot->m_Data << " ";
	InOrderTraversal(pRoot->m_pRight);
}

//递归算法后续遍历
template<class T>
void PostOrderTraversal(BSTreeNode<T>* pRoot){
	if (pRoot == NULL){
		return;
	}
	PostOrderTraversal(pRoot->m_pLeft);
	PostOrderTraversal(pRoot->m_pRight);
	cout << pRoot->m_Data << " ";
}

//非递归算法前序遍历
template<class T>
void PreOrderTraversal2(BSTreeNode<T>* pNode){
	stack<BSTreeNode<T>*> _stack;

	while (pNode || !_stack.empty()){
		while (pNode){
			_stack.push(pNode);
			cout << pNode->m_Data << " ";
			pNode = pNode->m_pLeft;
		}

		pNode = _stack.top();
		_stack.pop();

		pNode = pNode->m_pRight;
	}
}

//非递归算法中序遍历
template<class T>
void InOrderTraversal2(BSTreeNode<T>* pNode){
	stack<BSTreeNode<T>*> _stack;

	while (pNode || !_stack.empty()){
		while (pNode){
			_stack.push(pNode);
			pNode = pNode->m_pLeft;
		}

		pNode = _stack.top();
		_stack.pop();

		cout << pNode->m_Data << " ";

		pNode = pNode->m_pRight;
	}
}

//非递归算法后序遍历
template<class T>
void PostOrderTraversal2(BSTreeNode<T>* pNode)
{
	stack<BSTreeNode<T>*> _stack;

	if (pNode == NULL){
		return;
	}

	while (1){
		do{
			while (pNode){							//有左儿子进，无左子调用右儿子
				_stack.push(pNode);
				pNode = pNode->m_pLeft;
			}
			pNode = _stack.top()->m_pRight;			//无左子调用右儿子
		} while (pNode != NULL);

		while (1){
			BSTreeNode<T>* pCurr = _stack.top();
			_stack.pop();

			cout << pCurr->m_Data << " ";		//循环表示是从右儿子返回，则继续出栈

			if (_stack.empty())
				break;

			if (pCurr != _stack.top()->m_pRight)
				break;							//否则表明是从左儿子返回
		}
		if (_stack.empty())
			break;

		pNode = _stack.top()->m_pRight;
	}
}

//层序遍历
template<class T>
void LevelOrderTraversal(BSTreeNode<T>* pNode){
	queue<BSTreeNode<T>*> _queue;

	if (pNode){
		_queue.push(pNode);
	}

	while (!_queue.empty())
	{
		pNode = _queue.front();
		_queue.pop();

		cout << pNode->m_Data << " ";

		if (pNode->m_pLeft){
			_queue.push(pNode->m_pLeft);
		}
		if (pNode->m_pRight){
			_queue.push(pNode->m_pRight);
		}
	}
}

//递归算法计算树的高度
template<class T>
int Depth(BSTreeNode<T>* pNode){
	if (pNode == NULL)
		return 0;

	int depth1 = Depth(pNode->m_pLeft);
	int depth2 = Depth(pNode->m_pRight);

	return (depth1 > depth2 ? depth1 : depth2) + 1;
}

//递归算法计算树的节点个数
template<class T>
int NumOfNodes(BSTreeNode<T>* pRoot){
	if (pRoot == NULL)
		return 0;
	int num1 = NumOfNodes(pRoot->m_pLeft);
	int num2 = NumOfNodes(pRoot->m_pRight);
	return num1 + num2 + 1;
}

#endif //~_BSTREE_H_

测试代码:

#include "BSTree.h"

int _tmain(int argc, _TCHAR* argv[])
{
	BSTreeNode<int>* pRoot = new BSTreeNode<int>(10);
	pRoot->m_pLeft = new BSTreeNode<int>(6, new BSTreeNode<int>(4), new BSTreeNode<int>(8));
	pRoot->m_pRight = new BSTreeNode<int>(14, new BSTreeNode<int>(12), new BSTreeNode<int>(16));

	cout << "Depth : " << Depth(pRoot) << endl;
	cout << "NumOfNodes : " << NumOfNodes(pRoot) << endl;

	cout << "-------------------------" << endl;

	PreOrderTraversal<int>(pRoot);
	cout << endl;
	InOrderTraversal<int>(pRoot);
	cout << endl;
	PostOrderTraversal<int>(pRoot);
	cout << endl;

	cout << "-------------------------" << endl;

	PreOrderTraversal2<int>(pRoot);
	cout << endl;
	InOrderTraversal2<int>(pRoot);
	cout << endl;
	PostOrderTraversal2<int>(pRoot);
	cout << endl;

	cout << "-------------------------" << endl;
	LevelOrderTraversal<int>(pRoot);
	cout << endl;
    <span style="font-family: Arial, Helvetica, sans-serif;">	return 0;</span>
}

测试结果:

Depth : 3
NumOfNodes : 7
-------------------------
10 6 4 8 14 12 16
4 6 8 10 12 14 16
4 8 6 12 16 14 10
-------------------------
10 6 4 8 14 12 16
4 6 8 10 12 14 16
4 8 6 12 16 14 10
-------------------------
10 6 14 4 8 12 16