94. 二叉树的中序遍历（Python、Java）

1 题目

链接：二叉树的中序遍历

给定一个二叉树，返回它的中序遍历（左根右）。

示例:

输入: [1,null,2,3]
1
　\
　　2
　/
3

输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

2 Python

2.1 方法一：迭代（即循环）

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        stack = []
        ans = []
        while root or stack:
            if root: #只要节点非空
                stack.append(root) #这里要加入的是树，不是树的值
                root = root.left
            else:
                root = stack.pop()
                ans.append(root.val) #树才有val和right
                root = root.right #左节点寻找完毕
        return ans

首先先达到root的最左端的左节点的位置，用stack记录经过所有节点，然后开始stack出栈，得到上一级节点的值，并加入ans，接着访问右节点，若为空，temp继续出栈，得到上上级节点，以此类推，最后stack为空，并且此时达到最右端的右节点

注：stack.append(root)，这里加的是root，不是root.val

2.2 方法二：递归

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        ans = []
        
        if not root:
            return ans
        else:
	        ans += self.inorderTraversal(root.left)            
	        ans += [root.val]
	        ans += self.inorderTraversal(root.right)
        
        return ans

二叉树的中序遍历：左根右
N叉树的前序遍历：根左右
N叉树的后序遍历：左右根

3 Java

3.1 方法一（递归）

先放一个错误案例，错误原因是 list 的 .addAll(另一list) 方法括号内不能是null，.add() 方法括号内可以为null
所以当 root = null，返回值不应为null，应为空 list

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root == null)    return null;
        List<Integer> ans = new LinkedList<Integer>();

        ans.addAll(inorderTraversal(root.left));	// 报错行
        ans.add(root.val);
        ans.addAll(inorderTraversal(root.right));
        return ans;
    }
}

修改后

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new LinkedList<Integer>();
        if(root == null)    return ans;

        ans.addAll(inorderTraversal(root.left));
        ans.add(root.val);
        ans.addAll(inorderTraversal(root.right));
        return ans;
    }
}

3.2 方法二（迭代）

中序遍历是左根右，所以要从树的最左下角开始遍历
分两步，一是压栈，二是取值
向最左子树移动（压栈）：若未达最左子树（root存在，可能还有左子树），root入栈等待处理，并移至root左子树**（注意不是判断root左子树是否存在！！！）**；
处理root节点（取值）：若已达最左子树（root不存在，无左子树），且stack非空，弹出栈顶节点，记录root值（该root无左子树），再移至root右子树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new LinkedList<Integer>();
        if(root == null)    return ans;
        Stack<TreeNode> stack = new Stack<TreeNode>();

        while(root != null  || !stack.empty()){
            // 向最左子树移动（压栈）：若未达最左子树，压栈等待处理
            if(root != null){
                stack.push(root);
                root = root.left;
            }
            // 处理root节点（取值）：若已达最左子树，但仍有节点需要处理
            else if(!stack.empty()){
                root = stack.pop();
                ans.add(root.val);
                root = root.right;
            }
        }
        return ans;
    }
}