题目信息

题目地址：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

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

示例：

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

1
2
3
4
5
6
7
8
9
10
11
12
    3
   / \
  9  20
    /  \
   15   7
返回其层序遍历结果：

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

解法一：广度优先遍历

没想到这题居然还是中等，来人！

言归正传，题目让你层序遍历也就是广度遍历然后放到容器里。就是纯遍历一次没有别的操作了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public List<List<Integer>> levelOrder(TreeNode root) {
    //定义结果集
    List<List<Integer>> result = new ArrayList<>();
    //根节点为空
    if(root = null) return result;
    //实现队列(也可以用别的LinkedList快一点)
    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    queue.offer(root);
    while(!queue.isEmpty()){
        //每一层的遍历
        List<Integer> level = new ArrayList<Integer>();
        int size = queue.size();
        for(int i = 0; i < size; i++){
            TreeNode node = queue.poll();
            level.add(node);
            if(node.left != null) queue.offer(node.left);
            if(node.right != null) queue.offer(node.right);
        }
        result.add(level);
    }
    return result;
}

遍历整个树时间复杂度O（n），队列小于n空间复杂度为O（n）

解法二：深度优先遍历

这里我们折腾一下，这题广度就是题目它的意思来的。但偏偏就要用深度写

不同的是广度每次内层循环就完成一层节点的遍历，外层去添加这一层的List，深度的话遍历第一个是第一层的第二个就是第二层了第三个就是第三层的第一个了，因此需要先记下层级

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public List<List<Integer>> levelOrder(TreeNode root) {
    //结果集
    List<List<Integer>> result = new ArrayList<List<Integer>>();
	if(root == null) return result;
	dfs(1,root,result);
    return result;
}
	
public void dfs(int level, TreeNode root, List<List<Integer>> result) {
    //容器大小小于层级则添加一个新层级
	if(result.size()<level) {
		result.add(new ArrayList<Integer>());
	}
    //往对应的层级List添加值
	result.get(level - 1).add(root.val);
	//往下面走，层级+1
	if(root.left!=null) {
		dfs(level+1, root.left, result);
	}
	if(root.right!=null) {
        dfs(level+1, root.right, result);
    }
}

总结

还是与之前一样，用来熟悉树的遍历，基本上一个题两大种遍历方式都是可以完成，只不过是适用性不一样。总之多思考多熟练树遍历的操作过程