题目描述

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

提示：

树的高度不会超过 1000
树的节点总数在 [0, 10^4] 之间

解题思路

和经典的层序遍历类似，每访问一个结点就将其入队。但此题略有不同，需要将每一层的结点单独放在一个列表里，所以定义中间变量$l$和$q0$传递信息。
我在写这个题的时候犯了一个低级错误：中间变量$l$和$q0$将信息传递过去后，我直接将其clear，但由于是引用传递而非值传递，所以被传递过去的信息也被清空了。可以用new LinkedList<>(q0)的方式申请一块新的内存，再赋值给$q$，变量$l$同理。

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        if(root==null)
            return new LinkedList<>();
        List<List<Integer>> list=new ArrayList<>();//返回列表
        List<Integer> l=new LinkedList<>();//每层列表
        Queue<Node> q=new LinkedList<>();//定义队列，保存要访问的结点
        Queue<Node> q0=new LinkedList<>();//中间队列，用以区分每一层
        q.offer(root);
        while(!q.isEmpty()){
            Node n=q.poll();
            l.add(n.val);
            if(n.children!=null)
                for(Node n0:n.children)
                    q0.offer(n0);
            if(q.isEmpty()) {
                list.add(new LinkedList<>(l));
                q=new LinkedList<>(q0);
                l.clear();
                q0.clear();
            }
        }
        return list;
    }
}

测试例程

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }
    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
}

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        if(root==null)
            return new LinkedList<>();
        List<List<Integer>> list=new ArrayList<>();//返回列表
        List<Integer> l=new LinkedList<>();//每层列表
        Queue<Node> q=new LinkedList<>();//定义队列，保存要访问的结点
        Queue<Node> q0=new LinkedList<>();//中间队列，用以区分每一层
        q.offer(root);
        while(!q.isEmpty()){
            Node n=q.poll();
            l.add(n.val);
            if(n.children!=null)
                for(Node n0:n.children)
                    q0.offer(n0);
            if(q.isEmpty()) {
                list.add(new LinkedList<>(l));
                q=new LinkedList<>(q0);
                l.clear();
                q0.clear();
            }
        }
        return list;
    }
    public void initNode(Node root,List<Integer> list){
        int len=list.size();
        if(len==0)
            return;
        Queue<Node> q=new LinkedList<>();//定义队列，保存要访问的结点
        Node n=root;
        int k0=1,k1=0;
//        List<Node> chi=new LinkedList<>();
        for(int i=0;i<len;i++){
            if(list.get(i) !=null){
                if(i==0) {
                    n.val = list.get(i);
                    q.offer(n);
                }
                else {
                    Node tmp=new Node(list.get(i));
                    if(n.children==null)
                        n.children=new LinkedList<>();
                    n.children.add(tmp);
                    q.offer(tmp);
                }
            }
            else {
//                k1++;
                if(q.isEmpty()){
                    break;
                }
                else{
                    n=q.poll();
                }
            }
        }
    }
    public static void main(String[] args){
        List<Integer> list=new LinkedList<>();
        Integer[] a=new Integer[]{1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14};
        for(int i=0;i<a.length;i++){
            list.add(a[i]);
        }
        Solution s=new Solution();
        Node root=new Node();
        s.initNode(root,list);
        List<List<Integer>> l=s.levelOrder(root);
        System.out.println(l);
    }
}