二叉树的非递归遍历

#ifndef __BINARYTREE_H__
#define __BINARYTREE_H__

#include <iostream>
#include <stack>
#include <queue>

using namespace std;

template <class Elem>
class BinaryTree
{
public:
	BinaryTree();
	void prevCreateTree();     //按先序序列创建二叉树
	void prevOrderTraverse();  //先序遍历二叉树
	void inOrderTraverse();    //中序遍历二叉树
	void postOrderTraverse();  //后序遍历二叉树
	void levelOrderTraverse(); //层序遍历二叉树
	void setFlag(Elem f);
	const Elem &getFlag() const;

private:
	struct BiTreeNode
	{
		Elem elem;
		struct BiTreeNode *lChild;
		struct BiTreeNode *rChild;
		BiTreeNode(Elem e)
			:elem(e), lChild(NULL), rChild(NULL)
		{
		}
	};

	BiTreeNode *root;
	Elem flag;                 //在创建二叉树时要有一个标记来表示创建到叶子结点了

	void prevCreateTree(BiTreeNode *&root, const Elem &flag); //按先序序列创建二叉树
	void prevOrderTraverse(BiTreeNode *root);                 //先序遍历二叉树
	void inOrderTraverse(BiTreeNode *root);                   //中序遍历二叉树
	void postOrderTraverse(BiTreeNode *root);                 //后序遍历二叉树
	void levelOrderTraverse(BiTreeNode *root);                //层序遍历二叉树
};

template <class Elem>
BinaryTree<Elem>::BinaryTree()
	:root(NULL)
{
}

template <class Elem>
void BinaryTree<Elem>::prevCreateTree()
{
	prevCreateTree(root, getFlag());
}

template <class Elem>
void BinaryTree<Elem>::prevOrderTraverse()
{
	prevOrderTraverse(root);
}

template <class Elem>
void BinaryTree<Elem>::inOrderTraverse()
{
	inOrderTraverse(root);
}

template <class Elem>
void BinaryTree<Elem>::postOrderTraverse()
{
	postOrderTraverse(root);
}

template <class Elem>
void BinaryTree<Elem>::levelOrderTraverse()
{
	levelOrderTraverse(root);
}

template <class Elem>
void BinaryTree<Elem>::setFlag(Elem f)
{
	flag = f;
}

template <class Elem>
const Elem &BinaryTree<Elem>::getFlag() const
{
	return flag;
}

template <class Elem>
void BinaryTree<Elem>::prevCreateTree(BiTreeNode *&root, const Elem &flag)
{
	Elem e;
	if(cin >> e && e != flag)
	{
		BiTreeNode *node = new BiTreeNode(e);
		root = node;
		prevCreateTree(root->lChild, flag);
		prevCreateTree(root->rChild, flag);
	}
}

template <class Elem>
void BinaryTree<Elem>::prevOrderTraverse(BiTreeNode *root)
{
	stack<BiTreeNode*> treeStack;
	if(root == NULL)
	{
		return ;
	}
	else
	{
		treeStack.push(root);          //根结点入栈
	}

	while(!treeStack.empty())
	{
		BiTreeNode *topNode = treeStack.top();
		cout << topNode->elem << endl; //遍历栈顶元素
		treeStack.pop();               //栈顶元素出栈
		if(topNode->rChild != NULL)    //右孩子入栈
		{
			treeStack.push(topNode->rChild);
		}
		if(topNode->lChild != NULL)    //左孩子入栈
		{
			treeStack.push(topNode->lChild);
		}
	}
}

template <class Elem>
void BinaryTree<Elem>::inOrderTraverse(BiTreeNode *root)
{
	stack<BiTreeNode*> treeStack;
	BiTreeNode *tempNode = NULL;

	if(root == NULL)
	{
		return ;
	}
	else
	{
		treeStack.push(root);         //根结点入栈
		tempNode = root->lChild;      //标记左孩子
	}

	while(!treeStack.empty() || tempNode != NULL)
	{
		if(tempNode != NULL)
		{
			treeStack.push(tempNode);    //如果左孩子不为空，入栈
			tempNode = tempNode->lChild; //再次标记左孩子
		}
		else
		{
			//如果左孩子为空，则遍历栈顶元素，然后遍历右子树
			BiTreeNode *topNode = treeStack.top();
			cout << topNode->elem << endl;
			treeStack.pop();
			tempNode = topNode->rChild;
		}
	}
}

template <class Elem>
void BinaryTree<Elem>::postOrderTraverse(BiTreeNode *root)
{
	//正在学习ing...
}

template <class Elem>
void BinaryTree<Elem>::levelOrderTraverse(BiTreeNode *root)
{
	queue<BiTreeNode*> treeQueue;
	if(root == NULL)
	{
		return ;
	}
	else
	{
		treeQueue.push(root);
	}

	while(!treeQueue.empty())
	{
		BiTreeNode *frontNode = treeQueue.front();
		cout << frontNode->elem << endl;
		treeQueue.pop();
		if(frontNode->lChild != NULL)
		{
			treeQueue.push(frontNode->lChild);
		}
		if(frontNode->rChild != NULL)
		{
			treeQueue.push(frontNode->rChild);
		}
	}
}
#endif