【LeetCode】102. Binary Tree Level Order Traversal 二叉树的层序遍历 (Python&C++)

时间：2023-03-09 05:59:23
【LeetCode】102. Binary Tree Level Order Traversal 二叉树的层序遍历 (Python&C++)

题目地址：https://leetcode.com/problems/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).

For example:

Given binary tree [3,9,20,null,null,15,7],

    3

   / \

  9  20

    /  \

   15   7

return its level order traversal as:

[

  [3],

  [9,20],

  [15,7]

]

题目大意

层次遍历二叉树。

解题方法

BFS

BFS使用队列，把每个还没有搜索到的点依次放入队列，然后再弹出队列的头部元素当做当前遍历点。BFS总共有两个模板：

  1. 如果不需要确定当前遍历到了哪一层，BFS模板如下。
while queue 不空：

    cur = queue.pop()

    for 节点 in cur的所有相邻节点：

        if 该节点有效且未访问过：

            queue.push(该节点)
  1. 如果要确定当前遍历到了哪一层，BFS模板如下。
    这里增加了level表示当前遍历到二叉树中的哪一层了，也可以理解为在一个图中，现在已经走了多少步了。size表示在当前遍历层有多少个元素，也就是队列中的元素数，我们把这些元素一次性遍历完，即把当前层的所有元素都向外走了一步。
level = 0

while queue 不空：

    size = queue.size()

    while (size --) {

        cur = queue.pop()

        for 节点 in cur的所有相邻节点：

            if 该节点有效且未被访问过：

                queue.push(该节点)

    }

    level ++;

上面两个是通用模板，在任何题目中都可以用，是要记住的！

本题要求二叉树的层次遍历，所以同一层的节点应该放在一起，故使用模板二。

使用队列保存每层的所有节点，每次把队列里的原先所有节点进行出队列操作，再把每个元素的非空左右子节点进入队列。因此即可得到每层的遍历。

Python代码如下：

# Definition for a binary tree node.

# class TreeNode(object):

#     def __init__(self, x):

#         self.val = x

#         self.left = None

#         self.right = None

class Solution(object):

    def levelOrder(self, root):

        """

        :type root: TreeNode

        :rtype: List[List[int]]

        """

        res = []

        if not root: return res

        queue = collections.deque()

        queue.append(root)

        while queue:

            level = []

            for i in range(len(queue)):

                node = queue.popleft()

                level.append(node.val)

                if node.left:

                    queue.append(node.left)

                if node.right:

                    queue.append(node.right)

            res.append(level)

        return res

DFS

本题使用 DFS 同样能做。由于题目要求每一层的节点都是从左到右遍历，因此递归时也要先递归左子树、再递归右子树。

DFS 做本题的主要问题是： DFS 不是按照层次遍历的。为了让递归的过程中同一层的节点放到同一个列表中，在递归时要记录每个节点的深度 level。递归到新节点要把该节点放入 level 对应列表的末尾。

当遍历到一个新的深度 level，而最终结果 res 中还没有创建 level 对应的列表时，应该在 res 中新建一个列表用来保存该 level 的所有节点。

Python 代码：

# Definition for a binary tree node.

# class TreeNode(object):

#     def __init__(self, x):

#         self.val = x

#         self.left = None

#         self.right = None

class Solution(object):

    def levelOrder(self, root):

        """

        :type root: TreeNode

        :rtype: List[List[int]]

        """

        res = []

        self.level(root, 0, res)

        return res

    def level(self, root, level, res):

        if not root: return

        if len(res) == level: res.append([])

        res[level].append(root.val)

        if root.left: self.level(root.left, level + 1, res)

        if root.right: self.level(root.right, level + 1, res)

C++代码如下：

/**

 * Definition for a binary tree node.

 * struct TreeNode {

 *     int val;

 *     TreeNode *left;

 *     TreeNode *right;

 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}

 * };

 */

class Solution {

public:

    vector<vector<int>> levelOrder(TreeNode* root) {

        vector<vector<int>> res;

        dfs(res, root, 0);

        return res;

    }

    void dfs(vector<vector<int>>& res, TreeNode* root, int level) {

        if (!root) return;

        if (level >= res.size())

            res.push_back(vector<int>());

        res[level].push_back(root->val);

        dfs(res, root->left, level + 1);

        dfs(res, root->right, level + 1);

    }

};

日期

2018 年 3 月 14 日
2019 年 9 月 20 日 —— 是选择中国互联网式加班？还是外企式养生？

相关文章