[Java·算法·中等]LeetCode102. 二叉树的层序遍历

️ 力扣原文

题目

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

输入：root = [1]
输出：[[1]]

输入：root = []
输出：[]

分析思路1

广度优先搜索（BFS）:
判断根节点是否为空，如果为空则直接返回一个空列表。接着，我们定义一个队列 queue，并将根节点加入队列中。然后，我们使用 while 循环遍历队列中的每个节点，对于每个节点，我们从队列中取出并加入到当前层的节点列表 level 中，并将其左右子节点加入到队列中。在遍历完一层后，将该层的节点列表 level 加入到结果列表 result 中，并继续下一层的遍历。最后，返回结果列表 result 即可。

题解1

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> level = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(level);
        }

        return result;
    }
}

执行结果

分析思路2

深度优先搜索（DFS）：
定义一个空的 Map map，用来保存每个节点所在的层数以及该层的节点列表。然后，我们调用 dfs 方法来遍历整个二叉树。在 dfs 方法中，我们首先判断当前节点是否为空，如果为空则直接返回。接着，我们获取当前节点所在的层数 level 对应的节点列表 levelList，如果该列表不存在则创建一个新的空列表。然后，将当前节点的值加入到该层的节点列表 levelList 中，并将其更新到 map 中。接着，我们对当前节点的左右子节点进行递归调用 dfs 方法，同时将层数 level + 1，以便将子节点加入到对应的节点列表中。

最后，我们将 map 中所有的节点列表取出，并加入到一个新的 ArrayList 中，然后将该列表作为结果返回即可。

题解2

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        dfs(root, map, 0);
        return new ArrayList<>(map.values());
    }

    private void dfs(TreeNode node, Map<Integer, List<Integer>> map, int level) {
        if (node == null) {
            return;
        }

        List<Integer> levelList = map.getOrDefault(level, new ArrayList<>());
        levelList.add(node.val);
        map.put(level, levelList);

        dfs(node.left, map, level + 1);
        dfs(node.right, map, level + 1);
    }
}

执行结果