[lintcode easy]Binary Tree Postorder Traversal

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Postorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> list=new ArrayList<Integer>();
        if(root==null) return list;
        
        Stack<TreeNode> stack=new Stack<TreeNode>();
        stack.push(root);
        
        TreeNode prev=null;
        while(!stack.empty())
        {
            // go down the tree.
            //check if current node is leaf, if so, process it and pop stack,
            //otherwise, keep going down

            TreeNode cur=stack.peek();
            if(prev==null||prev.left==cur||prev.right==cur)
            {
                if(cur.left!=null)
                {
                    stack.push(cur.left);
                }
                else if(cur.right!=null)
                {
                    stack.push(cur.right);
                }
                else
                {
                    stack.pop();
                    list.add(cur.val);
                }
                
            }
             //go up the tree from left node    
            //need to check if there is a right child
            //if yes, push it to stack
            //otherwise, process parent and pop stack

            else if(cur.left==prev)
            {
                if(cur.right!=null)
                {
                    stack.push(cur.right);
                }
                else
                {
                    stack.pop();
                    list.add(cur.val);
                }
            }
            //go up the tree from right node 
            //after coming back from right node, process parent node and pop stack. 
            else if(cur.right==prev)
            {
                stack.pop();
                list.add(cur.val);
            }
            prev=cur;
           
        }
        return list;
    }
}