429. N 叉树的层序遍历（java实现）--LeetCode

本文链接：https://blog.csdn.net/qq_38783664/article/details/112692005

文章目录

题目：

给定一个 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] 之间

解法1：DFS

/**
 * 思路：
 * 递归，记录当前的层级
 * 只要当前的层级大于等于了，当前结果集的长度就创建一个ArrayList
 * 之后获取当前层级的ArrayList，加入当前元素
 * 递归
 */
    public List<List<Integer>> levelOrder(Node root) {
        ArrayList<List<Integer>> result = new ArrayList<>();
        recursive(root,result,0);
        return result;
    }

    private void recursive(Node root, ArrayList<List<Integer>> result, int level) {
        if (root==null)return;
        if (level>=result.size()){
            result.add(new ArrayList<>());
        }
        result.get(level).add(root.val);
        for (Node n:root.children){
            recursive(n,result,level+1);
        }
    }

时间复杂度：On

空间复杂度：On
在这里插入图片描述

解法2：BFS

/**
 * 思路：
 * 给每层创建一个集合，从当前层获取下一层的所有节点加到下一层的集合中
 * 并把当前层的所有节点加到集合中
 */
    public List<List<Integer>> levelOrder2(Node root) {
        ArrayList<List<Integer>> result = new ArrayList<>();
        if (root==null)return result;
        ArrayDeque<Node> queue = new ArrayDeque<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            ArrayList<Integer> list = new ArrayList<>();
            int size = queue.size();
            for (int i=0;i<size;i++) {
                Node poll = queue.poll();
                list.add(poll.val);
//                List<Node> children = poll.children;
//                for (int i=0;i<children.size();i++){
//                    queue.add(children.get(i));
//                }
                queue.addAll(poll.children);
            }
            result.add(list);
        }
        return result;
    }

时间复杂度：On^2

空间复杂度：On
在这里插入图片描述
第二种写法：

    public List<List<Integer>> levelOrder(Node root) {
        ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
        if (root==null)return result;
        List<Node> current = Arrays.asList(root);
//        while (current!=null){这个会超时的原因：集合的底层是数组，判断条件不是null，而是为0。isEmpty底层判断也是为0
        while (!current.isEmpty()){
            ArrayList<Integer> level = new ArrayList<Integer>();
            ArrayList<Node> next = new ArrayList<Node>();
            for (Node node:current){
                level.add(node.val);
                next.addAll(node.children);
            }
            result.add(level);
            current=next;
        }
        return result;
    }