链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
示例：
二叉树：[3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回其层次遍历结果：
[
[3],
[9,20],
[15,7]
]
思路1：广度优先搜索，从树的根节点开始，一层一层的遍历到叶子节点
# 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]]
"""
if not root: # 边界条件，root为空，直接返回一个空列表
return []
result = [] # 存储每层节点的val值所组成的列表
queue = collections.deque() # 建立一个队列
queue.append(root)
# visited = set(root) 这里遍历的是二叉树，不存在重复节点；如果遍历图，还需要维护一个已访问节点的集合，用来判重
while queue: # 按层循环，每次循环取出所有元素，同时添加下一层的所有元素，直到最后一层，不再有新元素为止
level_size = len(queue) # 每一层节点的个数
cur_level_val = [] # 存储当前层节点的val值
# 循环取出队列当前的所有元素（所有元素都在同一层内），将当前元素的val存进一个列表，将当前元素的子节点存入queue
for i in range(level_size):
# 循环取出当前层所有节点并处理
node = queue.popleft()
cur_level_val.append(node.val) # 将当前节点的值添加到 cur_level_val
# 判断是否存在下一层节点，并存储到queue中
if node.left:
queue.append(node.left) # 如果当前节点的左子节点存在，添加到队列中
if node.right:
queue.append(node.right)# 如果当前节点的左子节点存在，添加到队列中
#将当前层所有节点的val集合，存入result
result.append(cur_level_val)
return result
时间复杂度：O(n)
空间复杂度：O(n)
java版本
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res = new ArrayList<>();
if(root == null)
return res;
LinkedList<TreeNode> queue = new LinkedList<>();
queue.add(root);
while(!queue.isEmpty()){
int sizeOfLevel = queue.size();
List<Integer> currentLevel = new ArrayList<>();
for(int i = 0 ;i < sizeOfLevel;i++){
TreeNode node = queue.poll();
currentLevel.add(node.val);
if(node.left != null)
queue.add(node.left);
if(node.right != null)
queue.add(node.right);
}
res.add(currentLevel);
}
return res;
}
}
思路2：深度优先搜索——递归方案
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
if not root: # 边界判断
return []
self.result = [] # 存储最终结果
self.process(root,0) # 实际的逻辑处理
return self.result # 返回结果
def process(self,node,level): # node 为当前节点 ，level为当前节点所处的层次
# base case
if not node:
return
# 判断result中是否已经存在存储当前层元素的列表，如果不存在，则添加一个空列表
if len(self.result) < level+1: # level是从0 开始的，所以需要加1
self.result.append([])
self.result[level].append(node.val) # 将当前节点数据，添加到存储当前level数据的列表中
# 递归处理左右子节点
self.process(node.left,level+1)
self.process(node.right,level+1)