145. 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?

链接：https://leetcode.com/problems/binary-tree-postorder-traversal/#/description

5/10/2017

算法班

还可以refactor，不过不如这个好理解

public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ret = new ArrayList<Integer>();
        if (root == null) return ret;

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode current = root;
        TreeNode previous = null;

        stack.push(current);

        while (!stack.empty()) {
            current = stack.top();
            if (previous == null || previous.left == current || previous.right == current) {
                // down
                if (current.left != null) {
                    // has left, push left
                    stack.push(current.left);
                } else if (current.right != null) {
                    // no left has right, push right
                    stack.push(current.right);
                } else {
                    // no children, add to ret, pop
                    ret.add(current.val);
                    stack.pop();
                }
            } else if (current.left == previous) {
                // up from left
                if (current.right != null) {
                    // has right, push right
                    stack.push(current.right);
                } else {
                    // no right, add to ret, pop
                    ret.add(current.val);
                    stack.pop();
                }
            } else {
                // up from right
                // children traversal done, add to ret, pop
                ret.add(current.val);
                stack.pop();
            }
            previous = current;
        }
        return ret;
    }
}

九章官方，少了2部分的add/pop，原因是放在了下一次loop(prev == current, 落入最后一个else，再来add/pop)，但是不够明显。

上一个版本第37行是不包含prev == current的，原因是其他每一步里stack都有变化，要么pop，要么push，所以每一次Current必定有改变

九章版本里有空着的2个branch，所以第24行与上一版本的第37行是不一样的。

public ArrayList<Integer> postorderTraversal(TreeNode root) {
    ArrayList<Integer> result = new ArrayList<Integer>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode prev = null; // previously traversed node
    TreeNode curr = root;

    if (root == null) {
        return result;
    }

    stack.push(root);
    while (!stack.empty()) {
        curr = stack.peek();
        if (prev == null || prev.left == curr || prev.right == curr) { // traverse down the tree
            if (curr.left != null) {
                stack.push(curr.left);
            } else if (curr.right != null) {
                stack.push(curr.right);
            }
        } else if (curr.left == prev) { // traverse up the tree from the left
            if (curr.right != null) {
                stack.push(curr.right);
            }
        } else { // traverse up the tree from the right
            result.add(curr.val);
            stack.pop();
        }
        prev = curr;
    }

    return result;
}

别人的答案

用dequeue或者stack + reverse(cheat，我认为严格的面试管会质疑，并要求重写。。。)

https://discuss.leetcode.com/topic/30632/preorder-inorder-and-postorder-iteratively-summarization

更多讨论：

https://discuss.leetcode.com/category/153/binary-tree-postorder-traversal