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

一、题目

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

示例：

二叉树：[3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：

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

二、题目

1、BFS

思路：

层序遍历，BFS典型应用场景，理解比较简单，就从根节点开始，逐层往下扫描。理解相对简单，可参考下面二叉树层序遍历模板进行实现，这里还需要记录下层信息，所以需要改动模板。理解后多加练习以掌握。

二叉树层序遍历模板：

public List<List<Integer>> levelOrder(TreeNode root) {
    
    
    List<List<Integer>> allResults = new ArrayList<>();
    if (root == null) {
    
    
        return allResults;
    }
    Queue<TreeNode> nodes = new LinkedList<>();
    nodes.add(root);
    while (!nodes.isEmpty()) {
    
    
        int size = nodes.size();
        List<Integer> results = new ArrayList<>();
        for (int i = 0; i < size; i++) {
    
    
            TreeNode node = nodes.poll();
            results.add(node.val);
            if (node.left != null) {
    
    
                nodes.add(node.left);
            }
            if (node.right != null) {
    
    
                nodes.add(node.right);
            }
        }
        allResults.add(results);
    }
    return allResults;
}

代码：

/**
 * 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;
		Queue<TreeNode> q = new LinkedList<>();
		q.add(root);
		while(!q.isEmpty()) {
    
    
			int levelSize = q.size();
			List<Integer> currLevel = new ArrayList<>();
			for(int i = 0; i < levelSize; i++) {
    
    
				TreeNode currNode = q.poll();
				currLevel.add(currNode.val);
				if (currNode.left != null)
					q.add(currNode.left);
				if (currNode.right != null)
					q.add(currNode.right);
			}
			res.add(currLevel);
		}
		return res;
	}
}

时间复杂度： O(n)
空间复杂度： O(n)

2、DFS

思路：

DFS理解起来相对困难一点，这里演示下核心步骤。

Step 1：由第一个节点递归下去，到最深层。
[
  [3],
  [9],
  [15]
]

Step 2：然后往回走，从第二个节点开始，再到对应最深层。  这里节点数量有限，到此正好访问结束。
[
  [3],
  [9,20],
  [15,7]
]

DFS递归版本模板：

public List<List<Integer>> levelOrder(TreeNode root) {
    
    

	List<List<Integer>> allResults = new ArrayList<>();
	if(root==null)  return allResults;
	travel(root, 0, allResults);
	return allResults;
}

private void travel(TreeNode root, int level, List<List<Integer>> results){
    
    
    // process current node here. 
    if(results.size()==level)  results.add(new ArrayList<>());
    results.get(level).add(root.val);
    
    if(root.left!=null)  travel(root.left, level+1, results);
    if(root.right!=null)  travel(root.right, level+1, results);
}