树的中序遍历(递归，迭代，莫里斯)

所有涉及到中序遍历的题都可以使用该模板解决
中序遍历(inorderTraversal)有递归，迭代，莫里斯三种解法

递归版

public List<Integer> inorderTraversal(TreeNode root) {
	//具体的细节可以和这里不一样，但思路一致即可，就是左子树递归->root->右子树递归
    List<Integer> ans = new ArrayList<>();
    getAns(root, ans);
    return ans;
}

private void getAns(TreeNode node, List<Integer> ans) {
    if (node == null) {
        return;
    }
    getAns(node.left, ans); 
    ans.add(node.val);
    getAns(node.right, ans);
}

时间复杂度：O（n），遍历每个节点。

空间复杂度：O（h），压栈消耗，h 是二叉树的高度。

迭代版

Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
while(cur != null || !stack.isEmpty()){
	while(cur != null){
		stack.push(cur);
		cur = cur.left;
	}
	cur = stack.pop();
	/** do something **/
	cur = cur.right;
}

时间复杂度：O（n）。

空间复杂度：O（h），栈消耗，h 是二叉树的高度。

Morris遍历

解法一和解法二本质上是一致的，都需要 O（h）的空间来保存上一层的信息。而我们注意到中序遍历，就是遍历完左子树，然后遍历根节点。如果我们把当前根节点存起来，然后遍历左子树，左子树遍历完以后回到当前根节点cur就可以了，怎么做到呢？
我们注意到左子树cur.left最右边的节点last的右孩子是null，我们可以将last.right = cur即保留当前根节点即可，这样我们遍历完左子树，就可以回到根节点了。
如果当前根节点的左子树为null，那我们就直接遍历根节点，再考虑右子树cur = cur.right;

所以总体思想就是：记当前遍历的节点为 cur：

1. cur.left 为null,保存cur的值，更新cur为cur.right;
2. cur.left不为null，记prev = cur.left,找到左子树的最右边节点记为last；
3. 如果last.right为null，将last.right = cur;更新cur = cur.left;
4. 如果last.right不为null,说明之前已经访问过，第二次来到这里，表明当前子树遍历完成，将last.right = null;保存cur的值，更新cur为cur.right。
   结合图示：
   
   如上图，cur 指向根节点。 当前属于 3 的情况，cur.left 不为 null，cur 的左子树最右边的节点的右孩子为 null，那么我们把最右边的节点的右孩子指向 cur。
   
   接着，更新 cur = cur.left。
   
   如上图，当前属于 3 的情况，cur.left 不为 null，cur 的左子树最右边的节点的右孩子为 null，那么我们把最右边的节点的右孩子指向 cur。
   
   更新 cur = cur.left。
   
   如上图，当前属于情况 1，cur.left 为 null，保存 cur 的值，更新 cur = cur.right。
   
   如上图，当前属于 4 的情况，cur.left 不为 null，cur 的左子树最右边的节点的右孩子已经指向 cur，保存 cur 的值，更新 cur = cur.right。
   
   如上图，当前属于情况 1，cur.left 为 null，保存 cur 的值，更新 cur = cur.right。
   
   如上图，当前属于4的情况，cur.left 不为 null，cur 的左子树最右边的节点的右孩子已经指向 cur，保存 cur 的值，更新 cur = cur.right。
   
   当前属于情况 1，cur.left 为 null，保存 cur 的值，更新 cur = cur.right。
   
   cur 指向 null，结束遍历。

根据这个关系，写代码：

public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> ans = new ArrayList<>();
    TreeNode cur = root;
	while(cur != null){
		if(cur.left == null){
			ans.add(cur.val);  //do something
			cur = cur.right;
		}else{
			TreeNode prev = cur.left;
			while(prev.right != null && prev.right != cur)
				prev = prev.right;
			//情况3	
			if(prev.right == null){
				prev.right = cur;
				cur = cur.left;
			}	
			//情况4，不用担心前一个if会影响后一个，因为cur已经改变了
			if(prev.right == cur){
				prev.right = null;
				ans.add(cur.val);  //do something
				cur = cur.right;
			}
			
		}
	}
	return ans;   //依据实际情况返回

时间复杂度：O（n）。每个节点遍历常数次。

空间复杂度：O（1）。