Binary Tree Postorder Traversal

Given a binary tree, return the postorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

   1
    \
     2
    /
   3

return [3,2,1].

Note: Recursive solution is trivial, could you do it iteratively?

1. Recursive implementation

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void postorderTraversal(TreeNode root, ArrayList<Integer> res) {
        if(root==null) return;
        postorderTraversal(root.left, res);
        postorderTraversal(root.right, res);
        res.add(root.val);
        return;
    }
    
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        postorderTraversal(root, res);
        return res;
    }
}

2. Iterative implementation

http://leetcode.com/2010/10/binary-tree-post-order-traversal.html

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        if(root==null) return new ArrayList<Integer>();
        ArrayList<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        TreeNode pre = null;
        
        while(!stack.isEmpty()) {
            TreeNode cur = stack.peek();
            if(pre==null || pre.left==cur || pre.right==cur) {      // forward
                if(cur.left!=null) stack.push(cur.left);
                else if(cur.right!=null) stack.push(cur.right);
            }
            else if(cur.left == pre) {                              // backward from left
                if(cur.right!=null) stack.push(cur.right);
            }
            else if(cur.right==pre || pre==cur) {                   // backward from right or reach to a leaf
                res.add(cur.val);
                stack.pop();
            }
            pre = cur;
        }
        return res;
    }
}

3. 

Alternative Solution:
An alternative solution is to use two stacks. Try to work it out on a piece of paper. I think it is quite magical and beautiful. You will think that it works magically, but in fact it is doing a reversed pre-order traversal. That is, the order of traversal is a node, then its right child followed by its left child. This yields post-order traversal in reversed order. Using a second stack, we could reverse it back to the correct order.

Here is how it works:

1. Push the root node to the first stack.
2. Pop a node from the first stack, and push it to the second stack.
3. Then push its left child followed by its right child to the first stack.
4. Repeat step 2) and 3) until the first stack is empty.
5. Once done, the second stack would have all the nodes ready to be traversed in post-order. Pop off the nodes from the second stack one by one and you’re done.

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        if(root==null) return new ArrayList<Integer>();
        ArrayList<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> firstStack = new Stack<TreeNode>();
        Stack<TreeNode> secondStack = new Stack<TreeNode>();
        firstStack.push(root);
        
        while(!firstStack.isEmpty()) {
            TreeNode cur = firstStack.pop();
            secondStack.push(cur);
            if(cur.left!=null) firstStack.push(cur.left);
            if(cur.right!=null) firstStack.push(cur.right);
        }
        
        while(!secondStack.isEmpty()) {
            res.add(secondStack.pop().val);
        }
        
        return res;
    }
}