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].

Postorder is also a type of DFS. So we need to use a stack to help us control the visiting order of every node. Since we need to visit the root node at last, that means we would visit the root node in the scenario that traverses back from the children node. So we can separate this problem into two cases, one is to travel down and another is to travel back.

/**
 * 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) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        Stack buffer = new Stack<TreeNode>();
        TreeNode prev = null;
        if (root == null) {
			return result;
		}
        buffer.push(root);
        while (!buffer.isEmpty()) {
        	TreeNode cur = (TreeNode) buffer.peek();
        	// traverse down
        	if (prev == null || prev.left == cur || prev.right == cur) {
				if (cur.left != null) {
					buffer.push(cur.left);
				}
				else if (cur.right != null) {
					buffer.push(cur.right);
				}
				else {
					result.add(cur.val);
					buffer.pop();
				}
			}
        	// traverse back
        	else {
				// back from left
        		if (cur.left == prev) {
					// check right
        			if (cur.right != null) {
						buffer.push(cur.right);
					}
        			else {
						result.add(cur.val);
						buffer.pop();
					}
				}
        		//back from right
        		else {
					result.add(cur.val);
					buffer.pop();
				}
			}
        	prev = cur;
        }
        return result;
    }
}