二叉树非递归遍历

二叉树的非递归遍历中，前序和中序都比较简单。

前序遍历

    前序遍历只需要首先对每一个父节点输出，然后再处理左子，将左儿子压栈，由于是前序遍历压栈前都先输出该节点（弹栈的时候就不用输出，当然也不能在弹栈的时候输出），当最左子节点入栈后，开始通过弹栈处理右子节点，对于叶子节点或者没有右节点的子节点就不需要处理，对于每一个非空右子节点，其处理方式和根节点一样。总之就是压栈时处理左子节点，弹栈再处理右节点。

{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            cout<<p->data<<" ";
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->rchild;
        }
    }
}

中序遍历

    中序遍历和前序遍历的不同是，节点输出的顺序是，先左节点，然后父节点，最后右节点，相对前序遍历，只需要将压栈前输出节点改为每次弹栈时输出节点，其他一样。

{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            cout<<p->data<<" ";
            s.pop();
            p=p->rchild;
        }
    }    
}

后序遍历

解法一

 在三种遍历方式当中，后序遍历是最复杂的，因为每次弹栈之后要先处理该节点的右子节点，所以在压栈的时候，就要把左右子节点压栈，因为先入栈的后出栈，所以要先将右子节点入栈，再将左子节点入栈，这样在在到达最左子节点前，每次压入左右子节点后，最上面的就是左子节点，每次对最上面的节点重复上面的操作，知道最后压入的是最左子节点。然后开始输出操作，每次先看栈中最上面的一个若是叶子节点，则直接输出弹栈，若不是叶子结点，则判断上一个输出的是不是该节点的子节点，如果不是其子节点，则说明上一个输出的是该节点的左兄弟节点，这时候就要将该节点的左右节点按照前面的方式压栈处理。本方法的核心在于，每次压栈时右节点上面放的是左节点，若刚刚输出的是左兄弟，则有兄弟的儿子节点肯定是未考虑的，于是先处理该“右节点”的子节点。 

 

 

 

上图中数字代表压栈顺序，在最左子节点（7）入栈后，栈顶元素是叶子节点，于是可以直接输出并将其弹栈，这时记下刚输出的节点（7），然后接下来栈顶元素为（6），因为节点（7）不是（6）的儿子，也即刚刚输出的不是该节点的儿子，于是该节点不弹出，而是将其右子节点，左子节点分别压入栈，和之前一样，直到压入最左子节点。这时候如下图的8，9分别被压入，（9）在栈顶，执行和之前一样的操作，当8输出并弹栈的时候，栈顶就是（6），这时候对于节点（6），刚刚输出的节点（8）是其子节点，于是就可以输出（6）了。一直这样做，直到栈中没有元素为止。

void postOrder3(BinTree *root)     //非递归后序遍历
{
    stack<BinTree*> s;
    BinTree *cur;                      //当前结点 
    BinTree *pre=NULL;                 //前一次访问的结点 
    s.push(root);
    while(!s.empty())
    {
        cur=s.top();
        if((cur->lchild==NULL&&cur->rchild==NULL)||
           (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
        {
            cout<<cur->data<<" ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过 
              s.pop();
            pre=cur; 
        }
        else
        {
            if(cur->rchild!=NULL)
                s.push(cur->rchild);
            if(cur->lchild!=NULL)    
                s.push(cur->lchild);
        }
    }    
}

解法二
另外还可以使用一种更加直观的方式：不过相对解法一需要额外的O（n）的空间复杂度。

{
    stack<BinTree*> s;
    stack<BinTree*> printS;
    s.push(root);
    BinTree* pCur;
    while(!s.empty()){
         pCur = s.top();
         s.pop();
         printS.push(pCur);
         if(pCur->left != NULL) s.push(pCur->left);
         if(pCur->right != NULL) s.push(pCur->right);
    }
    while(!printS.empty()){
         pCur = printS.top();
         printS.pop();
         cout << pCur->val << endl;
    }    
}