文章目录
-
- Python3
-
- [方法一: 广度优先搜索 (BFS) ⟮ O ( n ) ⟯ \lgroup O(n) \rgroup ⟮O(n)⟯](#方法一: 广度优先搜索 (BFS) ⟮ O ( n ) ⟯ \lgroup O(n) \rgroup ⟮O(n)⟯)
- [方法二: 深度优先搜索 (DFS) ⟮ O ( n ) ⟯ \lgroup O(n) \rgroup ⟮O(n)⟯](#方法二: 深度优先搜索 (DFS) ⟮ O ( n ) ⟯ \lgroup O(n) \rgroup ⟮O(n)⟯)
- C++
-
- [方法一: 广度优先搜索 (BFS) ⟮ O ( n ) ⟯ \lgroup O(n) \rgroup ⟮O(n)⟯](#方法一: 广度优先搜索 (BFS) ⟮ O ( n ) ⟯ \lgroup O(n) \rgroup ⟮O(n)⟯)
Python3
方法一: 广度优先搜索 (BFS) ⟮ O ( n ) ⟯ \lgroup O(n) \rgroup ⟮O(n)⟯
python
# 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
python
# 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
方法二: 深度优先搜索 (DFS) ⟮ O ( n ) ⟯ \lgroup O(n) \rgroup ⟮O(n)⟯
DFS 做本题的主要问题是: DFS 不是按照层次遍历的。为了让递归的过程中同一层的节点放到同一个列表中,在递归时要记录每个节点的深度。递归到新节点要把该节点 对应深度列表的末尾。
python
# 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
C++
方法一: 广度优先搜索 (BFS) ⟮ O ( n ) ⟯ \lgroup O(n) \rgroup ⟮O(n)⟯
cpp
/**
* 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;
}
};