二叉树的非递归遍历实现

对于上一篇文章中介绍的二叉树结构，可以考虑使用非递归的方式进行不同的遍历方式，分别为：

1> 非递归先序遍历二叉树

2> 非递归中序遍历二叉树

3> 非递归后序遍历二叉树（标记法和非标记法）

4> 按二叉树层次序遍历二叉树

具体的二叉树的创建和打印等实现，参考前一篇文章，二叉树的实现

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

typedef char DataType;
typedef struct BinaryNode
{
DataType  data;
BinaryNode* lTree;
BinaryNode* rTree;
}BinNode, *BinTree;

typedef struct markTree
{
BinNode* node;
bool showFlag;
};

// 非递归先序遍历打印二叉树
void PreShowBinaryTree(BinTree tree)
{
if (NULL == tree) return;

std::stack<BinaryNode*> binStack;
BinaryNode* ptr = tree;
BinaryNode* tmp = NULL;
do
{
while(NULL != ptr)					  // 处理左子树
{
std::cout << " " << ptr->data;	  // 最先遇到的是跟结点 遇到就打印
binStack.push(ptr);
ptr = ptr->lTree;
}

if (binStack.empty()) continue;

tmp = binStack.top();				// 弹出根结点处理右子树
ptr = tmp->rTree;
binStack.pop();
} while (!(binStack.empty() && NULL == ptr));

}

// 非递归中序遍历打印二叉树
void InShowBinaryTree(BinTree tree)
{
if (NULL == tree) return;

std::stack<BinNode* > binStack;
BinNode* ptr = tree;
BinaryNode* tmp = NULL;
while(NULL != ptr || !binStack.empty())
{
while(NULL != ptr)
{
binStack.push(ptr);
ptr = ptr->lTree;
}

if (binStack.empty()) continue;

tmp = binStack.top();
std::cout << " " << tmp->data;		// 和先序打印最大的地方在于根节点的打印时间，中序在左子树遍历完成后打印根节点
binStack.pop();
ptr = tmp->rTree;
}
}

// 非递归后序遍历打印二叉树
// 后序遍历需要根节点两次出入栈， 第一次出栈是左子树遍历完成
// 第二次出栈是右子树遍历完成，后序遍历的重点在于处理打印时机，
// 需要在处理完左右子树后，才进行根节点的处理打印 showflag做
// 是否到了打印时机即右子树已经处理完的标志，动态更新
void PostShowBinaryTree(BinTree tree)
{
if (NULL == tree)
return;

std::stack<markTree> binStack;			// 需要借助标记结构markTree
BinNode* ptr = tree;
markTree tmp;

while(NULL != ptr || !binStack.empty())
{
while (NULL != ptr)						// 处理左子树， 每个根节点第一次入栈都showFlag初始化为false
{
tmp.node = ptr;
tmp.showFlag = false;
binStack.push(tmp);
ptr = ptr->lTree;
}

if (binStack.empty()) continue;

tmp = binStack.top();
binStack.pop();

if (!tmp.showFlag)						// 需要处理根节点的时候判断是不是已经处理过右子树，若已处理直接打印，若未处理完子树先处理
{
tmp.showFlag = true;
binStack.push(tmp);
ptr = tmp.node->rTree;
}
else
{
std::cout << " " << tmp.node->data;
ptr = NULL;
}
}
}

// 非递归后序遍历打印二叉树 不做额外标记
// 遍历栈，对于访问到的每一个root节点，先入栈。
// 如果root为叶子节点，则可以直接访问它
// 如果root存在左孩子或者右孩子，但是其左孩子和右孩子
// 都已被在这之前访问过了，则同样可以直接访问该结点，否则按照后序的反序方式
// root - right - left 一次入栈
void PostShowNotMark(BinTree tree)
{
if (NULL == tree)
return;

BinTree ptr;
BinTree last = NULL;				// 最后一次访问过的节点， 如果是单支左子树last未当前节点的左子树，否则为当前节点的右子树
std::stack<BinNode* > binStack;
binStack.push(tree);

while(!binStack.empty())
{
ptr = binStack.top();
if ((ptr->lTree == NULL && ptr->rTree == NULL) ||
(NULL != last && (last == ptr->lTree || last == ptr->rTree)))
{
last = ptr;
binStack.pop();
std::cout << " " << ptr->data;    // 判断是不是满足了可以打印需求
continue;
}

if (NULL != ptr->rTree)			  // 分别将又子树，左子树一次入栈
binStack.push(ptr->rTree);

if (NULL != ptr->lTree)
binStack.push(ptr->lTree);
}
}

// 按二叉层次遍历打印二叉树
// 按层次广度优先进行搜索，队列模拟即可
void LevelShowBinaryTree(BinTree tree)
{
if (NULL == tree) tree;
std::queue<BinNode* > binQueue;
binQueue.push(tree);
BinNode* ptr = NULL;

while(!binQueue.empty())
{
ptr = binQueue.front();
std::cout << " " << ptr->data;
binQueue.pop();

if (ptr->lTree != NULL)
binQueue.push(ptr->lTree);

if (ptr->rTree != NULL)
binQueue.push(ptr->rTree);
}
}