数据结构——二叉树的四种遍历方式（非递归）

二叉树遍历：  
前序遍历：根左右（栈实现）
中序遍历：左根右（栈实现）
后序遍历：左右根（栈实现）

层次遍历：从上往下遍历（队列实现）

结构体如下：

struct CTreeNode
{
  int m_Data;
  CTreeNode *m_lpLeft;
  CTreeNode *m_lpRight;
};

对于先序遍历，我们参考先序遍历的递归方式，先访问当前节点，递归左孩子，递归右孩子。

void PreOrder(CTreeNode *root)
{
	if (root != NULL)
	{
		printf("%d\n", root->m_Data);
		PreOrder(root->m_lpLeft);
		PreOrder(root->m_lpRight);
	}
}

我们知道调用函数的时候，调用函数会将会将被调用函数的参数压栈（当然还有保存当前运行环境例如返回地址寄存器啥的），然后执行。模仿这一机制，我们压栈的时候不是让系统自动压参数入栈，而是压入自己创建的栈中（局部变量）。首先访问当前节点，然后把左孩子入栈，接着访问左孩子的左孩子，然后把左孩子的左孩子入栈，直到某个节点的左孩子为空为止。这个时候，指针指向树的最左边，也就是栈中最上面的一个节点，取出该节点并访问其右孩子，将右孩子的左孩子入栈，重复上面操作。当栈为空时，说明所有节点访问完了，退出循环。

非递归代码如下：

void PreOrder(CTreeNode *lpNode)
{
    stack<CTreeNode*> stk;
    while(true)
    {
        while(lpNode != NULL)
        {
            printf("%d ", lpNode->m_Data);
            stk.push(lpNode);
            lpNode = lpNode->m_lpLeft;
        }
        if (stk.empty()) break;
        CTreeNode *lpPop = stack.top();
        stk.pop();
        lpNode = lpPop->m_lpRight;
    }
}

中序遍历和先序遍历很像，只不过节点是在从栈中弹出时才访问的。

void MidOrder(CTreeNode *lpNode)
{
    stack<CTreeNode*> stk;
    while(true)
    {
        while(lpNode != NULL)
        {
            stk.push(lpNode);
            lpNode = lpNode->m_lpLeft;
        }
        if (stk.empty()) break;
        CTreeNode *lpPop = stk.top();
        printf("%d ", lpPop->m_Data);
        stk.pop();
        lpNode = lpPop->m_lpRight;
    }
}

后序遍历比较麻烦，对于节点lpNode可以分情况讨论:

1. lpNode如果是叶子节点，直接输出。

2. lpNode如果有孩子，且孩子没有被访问过，则按照右孩子，左孩子的顺序依次入栈。

3. lpNode如果有孩子，而且孩子都已经访问过，则访问lpNode节点。
我们可以保存最后一个访问的节点lpLast，如果(lpNode->m_lpRight == NULL && lpNode->m_lpLeft == lpLast) || (lpNode->m_lpRight == lpLast)则说明lpNode的左右孩子都已经访问过了。

void PostOrder(CTreeNode *root)
{
	stack<CTreeNode *> stk;
	CTreeNode *lpLast = root;
	CTreeNode *lpNode;
	stk.push(root);
	
	while (!stk.empty())
	{
		lpNode = stk.top();

		if ((lpNode->m_lpLeft == NULL && lpNode->m_lpRight == NULL) 
                || (lpNode->m_lpRight == NULL && lpNode->m_lpLeft == lpLast) 
                || (lpNode->m_lpRight == lpLast))
		{
			printf("%d\n", lpNode->m_Data);
			lpLast = lpNode;
			stk.pop();//访问完了弹出
		}
		else
		{
			if (lpNode->m_lpRight)
			{
				stk.push(lpNode->m_lpRight);
			}
			if (lpNode->m_lpLeft)
			{
				stk.push(lpNode->m_lpLeft);
			}
		}
	}
}

层次遍历很简单：

void LayerOrder(CTreeNode* lpNode)
{
    queue<CTreeNode*> que;
    while(true)
    {
        printf("%d\n", lpNode->m_Data);
        if (lpNode->m_lpLeft != NULL)
            que.push(lpNode->m_lpLeft);
        if (lpNode->m_lpRight != NULL)
            que.push(lpNode->m_lpRight);
        if (que.empty())
            break;
        lpNode = que.front();
        que.pop();
    }
}