LeetCode 102: 二叉树的层序遍历 Binary Tree Level Order Traversal

题目:

给定一个二叉树，返回其按层次遍历的节点值。（即逐层地，从左到右访问所有节点）。

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

解题思路:

遍历顺序：逐层遍历

如下所示的二叉树：

       A
     /   \
   B       C
 /  \     /  \
D    E   F    G

其遍历顺序为：A -> B -> C -> D-> E -> F -> G

类似 N 叉树那种, 两种思路: 递归和迭代, 很简单, 类似的题目可以参考:

树的遍历 Traverse a Tree

LeetCode 589: N 叉树的前序遍历 N-ary Tree Preorder Traversal

LeetCode 590: N 叉树的后序遍历 N-ary Tree Postorder Traversal

LeetCode 429: N 叉树的层序遍历 N-ary Tree Level Order Traversal

递归法:

递归解法实际上是按照前序遍历的思路来的, 只不过加了一个行参 level(深度) 记录当前结点应该存在第几层

Java:

class Solution {
    List<List<Integer>> levels = new ArrayList<List<Integer>>();

    public void helper(TreeNode node, int level) {
        // 如果当前层级深度和待返回数组长度相等, 则新添加一个数组
        if (levels.size() == level)
            levels.add(new ArrayList<Integer>());

        // 在此深度的数组里添加当前结点值
        levels.get(level).add(node.val);

        // 递归(基线)条件
        if (node.left != null)
            helper(node.left, level + 1);
        if (node.right != null)
            helper(node.right, level + 1);
    }

    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null)
            return levels;
        helper(root, 0);
        return levels;
    }
}

Python:

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        res = []
        if not root:
            return res
        def levelOrderHelper(node: TreeNode, level: int):
            # 如果当前层级深度和待返回数组长度相等, 则新添加一个数组
            if len(res) == level:
                res.append([])
            #  在此深度的数组里添加当前结点值
            res[level].append(node.val)
            # 递归(基线)条件
            if node.left:
                levelOrderHelper(node.left, level+1)
            if node.right:
                levelOrderHelper(node.right, level+1)

        levelOrderHelper(root, 0)
        return res

迭代法:

Java:

class Solution {
    List<List<Integer>> levels = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null)
            return levels;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            // size 记录该层的结点总数
            int size = queue.size();
            // tmp 记录该层的结点值
            ArrayList<Integer> tmp = new ArrayList<>();
            // 添加该层所有结点的有效的左右孩子结点
            while (size-- > 0) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if (node.left != null)
                    queue.add(node.left);
                if (node.right != null)
                    queue.add(node.right);
            }
            levels.add(tmp);
        }
        return levels;
    }
}

Python:

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        res = []
        if not root:
            return res
        queue = collections.deque()
        queue.append(root)
        while queue:
            # size 记录该层的结点总数
            size = len(queue)
            # tmp 记录该层的结点值
            tmp = []
            # 添加该层所有结点的有效的左右孩子结点
            while size > 0:
                size -= 1
                node = queue.popleft()
                tmp.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(tmp)
        return res