【LeetCode】102. 二叉树的层序遍历

题目链接

Python3

方法一： 广度优先搜索 (BFS) $⟮O(n)⟯$

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        res = []
        queue =   [root,] 
        while queue: 
            tmp = [node.val for node in queue]
            res.append(tmp) # 取当前层 的结点值

            lis = [] ## 下一层 的结点
            for node in queue:
                if node.left:
                    lis.append(node.left)
                if node.right:
                    lis.append(node.right)

            queue = lis 

        return res

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        ans = []
        dq = deque([root])
        while dq: 
            level = [] ## 当前 遍历层
            n = len(dq)
            for _ in range(n):
                cur = dq.popleft()
                level.append(cur.val)
                # 下一层 存到  双端 队列 后面
                if cur.left:
                    dq.append(cur.left)
                if cur.right:
                    dq.append(cur.right)

            ans.append(level)

        return ans

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

方法二： 深度优先搜索 (DFS) $⟮O(n)⟯$

参考链接

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

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        # 子模块
        def helper(node, depth):
            # 记住结点的 深度
            if not node: return 
            if len(res) == depth:
                res.append([])
            res[depth].append(node.val)
            if node.left: helper(node.left, depth+1)
            if node.right: helper(node.right, depth+1)

        # 主模块
        if not root: return []
        res = []
        helper(root, 0)
        return res 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

C++

方法一： 广度优先搜索 (BFS) $⟮O(n)⟯$

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if (root == nullptr){
            return res;
        }

        queue <TreeNode*> q;
        q.emplace(root);
        while (!q.empty()){
            int n = q.size();
            res.emplace_back(vector<int> ());// 提前添加 空容器
            for (int i = 0; i < n; ++i){
                auto node = q.front(); q.pop();
                res.back().emplace_back(node->val);
                if (node->left){
                    q.emplace(node->left);
                }
                if (node->right){
                    q.emplace(node->right);
                }
            }

        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39