Leetcode-145-Binary Tree Postorder Traversal

使用非递归的方法写二叉树的后序遍历。印象中迭代的方法写树的遍历是用栈来写的。思路如下：

既然我们要通过压栈跳栈的方式来获取后序遍历，那么因为后序遍历的顺序是“左——右——根”，所以压栈的顺序应该是“根——右——左”。

接下来我们考虑什么时候应该跳栈。

• 若栈顶结点为叶子结点，我们可以弹出并访问该结点。
• 若栈顶结点非叶子结点，则该结点有孩子结点，此时若孩子结点没有被访问过，则按照右孩子，左孩子的顺序依次入栈；若孩子都已经访问过，则弹出并访问该结点。

ok，思路到目前为止都很简单，下一步要解决的问题就是如何判断某个结点的孩子结点是否都已经访问过。这需要我们记录最后访问过的结点pre。

• 若pre==cur->right，则cur结点的孩子结点都已经访问过。
• 若pre==cur->left且cur->right==NULL，则cur结点的孩子结点都已经访问过。

至此我们就可以写出完整的程序了：

class Solution 
{
public:
    vector postorderTraversal(TreeNode* root) 
    {
        vector ans;
        if(!root)
            return ans;
        stack st;
        st.push(root);
        TreeNode *pre=root,*cur=root;
        while(!st.empty())
        {
            cur=st.top();
            if((!cur->left&&!cur->right)||(pre==cur->right)||(pre==cur->left&&!cur->right))
            {
                ans.push_back(cur->val);
                pre=cur;
                st.pop();
            }
            else
            {
                if(cur->right)
                    st.push(cur->right);
                if(cur->left)
                    st.push(cur->left);
            }
        }
        return ans;
    }
};

除了这种方法以外，还有一种使用栈的后序遍历方法，相比上面的方法要更简单一些，但是使用空间会多一些。

这种方法的思路很简单，就是对于每个结点都压栈两遍，每次弹出一个结点赋给p，如果p仍然等于栈的头结点，说明p的孩子结点还没被访问过，应该把p的孩子结点压栈；如果p不等于栈的头结点，说明p的孩子都已经访问过，此时可直接访问p。也就是说，第一次弹出，将p的孩子压入栈中，第二次弹出，访问p。

class Solution 
{
public:
    vector postorderTraversal(TreeNode* root) 
    {
        vector ans;
        if(!root)
            return ans;
        stack st;
        st.push(root);
        st.push(root);
        TreeNode* p=root;
        while(!st.empty())
        {
            p=st.top();
            st.pop();
            if(!st.empty()&&p==st.top())
            {
                if(p->right) st.push(p->right),st.push(p->right);
                if(p->left) st.push(p->left),st.push(p->left);
            }
            else
                ans.push_back(p->val);
        }
        return ans;
    }
};

可以看到上面两种方法的用时已经比较短了，但空间使用的依然较多，有没有更好的办法呢？上次Leetcode-099-Recover Binary Search Tree中我们提到的Morris Traversal可以做到空间复杂度是O(1)，时间复杂度是O(n)。

以下代码自http://www.cnblogs.com/AnnieKim/archive/2013/06/15/morristraversal.html

后续遍历需要建立一个临时节点dump，令其左孩子是root。并且还需要一个子过程，就是倒序输出某两个节点之间路径上的各个节点。

步骤：

当前节点设置为临时节点dump。

1. 如果当前节点的左孩子为空，则将其右孩子作为当前节点。

2. 如果当前节点的左孩子不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点。

a) 如果前驱节点的右孩子为空，将它的右孩子设置为当前节点。当前节点更新为当前节点的左孩子。

b) 如果前驱节点的右孩子为当前节点，将它的右孩子重新设为空。倒序输出从当前节点的左孩子到该前驱节点这条路径上的所有节点。当前节点更新为当前节点的右孩子。

3. 重复以上1、2直到当前节点为空。

图示：

void reverse(TreeNode *from, TreeNode *to) // reverse the tree nodes 'from' -> 'to'.
{
    if (from == to)
        return;
    TreeNode *x = from, *y = from->right, *z;
    while (true)
    {
        z = y->right;
        y->right = x;
        x = y;
        y = z;
        if (x == to)
            break;
    }
}

void printReverse(TreeNode* from, TreeNode *to) // print the reversed tree nodes 'from' -> 'to'.
{
    reverse(from, to);
    
    TreeNode *p = to;
    while (true)
    {
        printf("%d ", p->val);
        if (p == from)
            break;
        p = p->right;
    }
    
    reverse(to, from);
}

void postorderMorrisTraversal(TreeNode *root) {
    TreeNode dump(0);
    dump.left = root;
    TreeNode *cur = &dump, *prev = NULL;
    while (cur)
    {
        if (cur->left == NULL)
        {
            cur = cur->right;
        }
        else
        {
            prev = cur->left;
            while (prev->right != NULL && prev->right != cur)
                prev = prev->right;

            if (prev->right == NULL)
            {
                prev->right = cur;
                cur = cur->left;
            }
            else
            {
                printReverse(cur->left, prev);  // call print
                prev->right = NULL;
                cur = cur->right;
            }
        }
    }
}