Binary Tree Inorder Traversal

https://oj.leetcode.com/problems/binary-tree-inorder-traversal/

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

For example:
Given binary tree {1,#,2,3},
   1
    \
     2
    /
   3
return [1,3,2].

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

confused what "{1,#,2,3}" means?

public List<Integer> inorderTraversal(TreeNode root)

这一题异常蛋疼，你直接recursion也能过。所谓循环做，依旧是用stack来模拟recursion。其实理论上来讲所有递归都可以stack来循环做，但是这并不一定是算法上的意义。只是你代替了compiler的call stack来做一个memory stack罢了。关于in-order，要仅遵守左中右的顺序就可以，下面给出代码。

    public List<Integer> inorderTraversal(TreeNode root) {
        Stack<TreeNode> node_stack = new Stack<TreeNode>();
        List<Integer> res = new LinkedList<Integer>();
        while(root != null || !node_stack.isEmpty()){
            if(root != null){
                node_stack.push(root);//事实上如果吧res.add(root.val)放在这里就成为了preorder。大家自己模拟推敲一下就知道了。
                root = root.left;
            }else{
                root = node_stack.pop();
                res.add(root.val);
                root = root.right;
            }
        }
        return res;
    }

2017-12-29 Updated：

我觉得在这里还是要给出preorder和postorder的循环处理为好。pre-order相对是比较简单的。

    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<Integer>();
        if (root == null) return result;
        Stack<TreeNode> treeStack = new Stack<TreeNode>();
        TreeNode currentNode = root;
        while(!treeStack.isEmpty() || currentNode != null) {
            if (currentNode != null) {
                result.add(currentNode.val);
                treeStack.push(currentNode);
                currentNode = currentNode.left;
            } else {
                currentNode = treeStack.pop();
                currentNode = currentNode.right;
            }
        }
        
        return result;
    }

可以看出来，我们只是把result.add(currentNode.val)从if转到了else。但是post order就显然麻烦许多。

简单来说，preorder是中左右，inorder是左中右，postorder是左右中。所以在preorder和inorder的做法里，我们的做法都是不停往尝试左走，把经过的节点堆入栈。当走到一个空指针节点（可以是因为往左走或是往右走）的时候，就pop出栈顶（也就是当前空指针的父亲节点），往右走一次。只是preorder和inorder唯一的区别是，preorder是正常走的过程里，就会不停把当前节点的值输出。inorder的时候只会在pop栈顶的时候输出。这样就符合了中左右和左中右的过程。至于postorder，因为原来的方式，pop栈顶的时候你是不知道来自于左空指针还是右空指针，所以左右中的顺序很难追踪。所以会需要一个previous指针去指认pop出来的指针。下面给出相关代码，并附注comment

    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<Integer>();
        if (root == null) return result;
        Stack<TreeNode> treeStack = new Stack<TreeNode>();
        TreeNode currentNode = null;
        TreeNode prevNode = null;
        treeStack.push(root);
        while(!treeStack.isEmpty()) {
            //这里只peek不pop，为的是可以不停往下走。
            currentNode = treeStack.peek();
            if ((currentNode.left == null && currentNode.right == null) ||
                (prevNode != null && (prevNode == currentNode.left || prevNode == currentNode.right))) {
                //(currentNode.left == null && currentNode.right == null) 
                //这个条件意思是到达了最底部的叶子结点，自然是要输出的。
                //而且我们把叶子结点全部放进栈里，所以pop完左叶子节点的，自然会pop右叶子节点。
                //(prevNode != null && (prevNode == currentNode.left || prevNode == currentNode.right)
                //这一段表示下面左右节点都走过了。左右中可以回到中了。所以我们要知道previousNode是不是自己的儿子们。
                //上面两段表示的就是，要不，我就是最孙子的孙子（这就是左右）。做完孙子了，那就看自己是不是从孙子回归的老子（中）
                result.add(currentNode.val);
                treeStack.pop();
                prevNode = currentNode;
            } else {
                //先push右再push左，就保证下一个指针pop出来的指针是先左后右的顺序
                if (currentNode.right != null) treeStack.push(currentNode.right);
                if (currentNode.left != null) treeStack.push(currentNode.left);
            }
        }
        
        return result;
    }

具体看comment。 另外这个方法参考了http://www.cnblogs.com/dolphin0520/archive/2011/08/25/2153720.html 给出链接尊重一下原作者。囧