LeetCode--Binary Tree Inorder Traversal

<span style="color: rgb(51, 51, 51); font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 24px; line-height: 1.1; background-color: rgb(255, 255, 255);">Binary Tree Inorder Traversal</span>

<span style="color: rgb(51, 51, 51); font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 24px; line-height: 1.1; background-color: rgb(255, 255, 255);">
</span>

题目链接：https://leetcode.com/problems/binary-tree-inorder-traversal/

对于树的题目，一般习惯想到两种方法实现，首先 ，最直观和简便的是递归。其次，便是通过在其他数据结构上寻求帮助，一般使用Stack或者Queue来实现。

首先，介绍递归的方法，时间复杂度是O(n)， 空间复杂度是O(lgn)。递归相对直观简单，是最长想到的方法。但常常面试的时候出于炫技的考虑，不推荐使用，毕竟递归人人都会。

</pre><pre name="code" class="java">public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        inorderTraversalHelper(root, list);
        return list;
    }
    
    public void inorderTraversalHelper(TreeNode root, List<Integer> list) {
        if(root == null) {
            return;
        }
        
        inorderTraversalHelper(root.left, list);
        list.add(root.val);
        inorderTraversalHelper(root.right, list);
    }
}

第二种要介绍的是使用stack最为辅助数据结构，来实现遍历。想法非常简单，就是按照inorder的遍历顺序，利用堆栈来维护当前遍历的节点。代码是这样的：

public class Solution {
    public 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 {
                TreeNode tmp = stack.pop();
                list.add(tmp.val);
                root = tmp.right;
            }
        }
        return list;
    }
}

最后，还有一只非常tricky的方法，空间复杂度控制在了常数，代价是破坏了树的结构，叫做Morris Traversal，有兴趣的同学可以上网查一下这个算法。