【Java】【LeetCode】94. Binary Tree Inorder Traversal

题目：

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

Example:

Input: [1,null,2,3]
   1
    \
     2
    /
   3

Output: [1,3,2]

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

题解：

需要结合栈来实现。先依次将根节点的所有左孩子入栈，当叶节点入栈后，将其出栈并访问，接着将其右孩子入栈，并继续将右孩子的左孩子入栈。。。循环退出条件为空指针且栈空，说明已经遍历到了最右端的节点。
其实原理和递归解法是差不多的，只不过将系统的堆栈换成由我们自己来实现。
时间和空间复杂度都是O（n）
 

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class BinaryTreeInorderTraversal {

    public static void main(String[] args) {
        /**
         * Given a binary tree, return the inorder traversal of its nodes' values.
         * 
         * Follow up: Recursive solution is trivial, could you do it iteratively?
         */
        /**
         * Example:
         * 
         * Input: [1,null,2,3] 1 \ 2 / 3
         * 
         * Output: [1,3,2]
         */
        TreeNode root = new TreeNode(1);
        TreeNode treeNode2 = new TreeNode(2);
        TreeNode treeNode3 = new TreeNode(3);
        root.right = treeNode2;
        treeNode2.left = treeNode3;
        System.out.println(inorderTraversal(root));
    }

    public static List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        if (root == null) {
            return list;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (root != null || !stack.isEmpty()) {
            if (root != null) {
                stack.push(root);
                root = root.left;
            } else {
                root = stack.pop();
                list.add(root.val);
                root = root.right;
            }
        }
        return list;
    }
}