题目

描述
给定一个二叉树，返回该二叉树层序遍历的结果，（从左到右，一层一层地遍历）
例如：
给定的二叉树是{3,9,20,#,#,15,7},

该二叉树层序遍历的结果是
[
[3],
[9,20],
[15,7]
]

数据范围：二叉树的节点数满足 1 \le n \le 10^5 \1≤n≤10
5

示例1
输入：{1,2}
返回值：[[1],[2]]
示例2
输入：{1,2,3,4,#,#,5}
返回值：[[1],[2,3],[4,5]]

解答

思路(BFS)

将每层的节点存入队列中，利用队列先进先出的特性依次将左孩子和右孩子存入队列，这样输出的时候就是层序遍历了。
这样会导致全部输出，不能体现哪一层有哪些数据，以案例二为例的输出结果为：[1,2,3,4,5]。加一点细节：
开一个新函数，每次记录下本层的子节点，下一次以记录下的子节点去寻找孙节点，以此类推就可以区分出哪一层有哪些节点啦。

代码

public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        // write code here
        if (root == null) {
            return null;
        }
//        存放节点
        //Queue> tempQueue = new LinkedList<>();
        Queue<TreeNode> queue = new LinkedList<>();
//        存放输出的值
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
//        将根节点加入队列并且结果存起来
        queue.add(root);
        //tempQueue.add(queue);
//        将每一层存起来
        while (queue.size() != 0) {
//            循环取值
            ArrayList<Integer> list = new ArrayList<>();
            Iterator<TreeNode> iterator = queue.iterator();
            //记录下本层的值
            while (iterator.hasNext()){
                int value = iterator.next().val;
                list.add(value);
//                 System.out.print(value);
            }
//             System.out.println();
            if(list != null){
                result.add(list);
            }
            //将子节点存储起来进入下一轮循环
            queue = this.findChild(queue);
        }
        return result;
    }

    /**
     * 获取当前层的所有子节点
     * @param queue
     * @return
     */
    public Queue<TreeNode> findChild(Queue<TreeNode> queue){
        //System.out.println(666);
        if (queue == null){
            return null;
        }
        Queue<TreeNode> result = new LinkedList<TreeNode>();
        Iterator<TreeNode> iterator = queue.iterator();
        while (iterator.hasNext()){
            TreeNode node = iterator.next();
            if (node.left != null){
                result.add(node.left);
            }
            if (node.right != null){
                result.add(node.right);
            }
        }
        return result;
    }
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

坑

while里面的条件不要写queue.peek() ，在这个方法是用来取值的，如果queue为空会报空指针异常。。。用iterator或者size方法就行了。

代码量更少版

public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        // write code here
        if (root == null) {
            return null;
        }
//        存放节点
        Queue<TreeNode> queue = new LinkedList<>();
//        存放输出的值
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
//        将根节点加入队列并且结果存起来
        queue.add(root);
        //tempQueue.add(queue);
//        将每一层存起来
        while (queue.size() != 0) {
//            循环取值
            ArrayList<Integer> list = new ArrayList<>();
            Iterator<TreeNode> iterator = queue.iterator();
            while (iterator.hasNext()){
                int value = iterator.next().val;
                list.add(value);
//                 System.out.print(value);
            }
//             System.out.println();
            if(list != null){
                result.add(list);
            }
//            queue = this.findChild(queue);

           Queue<TreeNode> newQueue = new LinkedList<>();
            Iterator<TreeNode> newIterator = queue.iterator();
            while (newIterator.hasNext()){
                TreeNode node = newIterator.next();
                if (node.left != null){
                    newQueue.add(node.left);
                }
                if (node.right != null){
                    newQueue.add(node.right);
                }
            }
           queue = newQueue;

        }
        return result;
    }
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
40
41
42
43
44

代码最少版

public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        // write code here
        if (root == null) {
            return null;
        }
//        存放节点
        Queue<TreeNode> queue = new LinkedList<>();
//        存放输出的值
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
//        将根节点加入队列并且结果存起来
        queue.add(root);
        //tempQueue.add(queue);
//        将每一层存起来
        while (queue.size() > 0) {
//            循环取值
            ArrayList<Integer> list = new ArrayList<>();
//             Iterator iterator = queue.iterator();
//             用来存放本层所有子节点
           Queue<TreeNode> newQueue = new LinkedList<>();
//             将本层的值存入结果集并找到所有子节点
            while (queue.size() > 0){
                TreeNode node = queue.poll();
                int value = node.val;
                list.add(value);
                if (node.left != null){
                    newQueue.add(node.left);
                }
                if (node.right != null){
                    newQueue.add(node.right);
                }
//                 System.out.print(value);
            }
//             System.out.println();
            if(list != null){
                result.add(list);
            }
           queue = newQueue;

        }
        return result;
    }
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
40
41

别人的解答

思路(前序遍历)

就是根据根、左、右的思想将每一层节点存起来，然后再获得其值。

代码

//这里写在函数参数里也行
ArrayList<ArrayList<Integer>> result = new ArrayList<>();
    public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        // write code here
        searchFront(root,0);
        return result;
    }
    
    public void searchFront(TreeNode root,Integer level){
        if(root == null){
            return;
        }
//         当前层遍历完毕,给结果集（二维数组）新加一个一维数组用于接收下一层数据
        if(level >= result.size()){
            result.add(new ArrayList<>());
        }
//         先获得当前节点应当存放的一维数组位置
        result.get(level).add(root.val);
        searchFront(root.left,level+1);
        searchFront(root.right,level+1);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

总结

对我来说这道题的难点就是如何将每一层的数据分别存放在一个数组中。