zoukankan      html  css  js  c++  java
  • 429. N 叉树的层序遍历

    429. N 叉树的层序遍历

    题目链接:429. N 叉树的层序遍历

    题目描述

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

    题解

    思路:这道题与“二叉树”的层次遍历一样,只是孩子节点变多了而已。

    代码(c++):

    class Node {
    public:
        int val;
        vector<Node*> children;
        Node() {}
        Node(int _val) {
            val = _val;
        }
        Node(int _val, vector<Node*> _children) {
            val = _val;
            children = _children;
        }
    };
    ​
    class Solution {
    public:
        vector<vector<int>> levelOrder(Node* root) {
            queue<Node*> que;
            if (root != nullptr) que.push(root);
            vector<vector<int>> result;
    ​
            while (!que.empty()) {
                int size = que.size();
                vector<int> temp;
                for (int i = 0; i < size; i++) {
                    Node* node = que.front();
                    que.pop();
                    temp.push_back(node->val);
                    for (int j = 0; j < node->children.size(); j++) {
                        if (node->children[j] != nullptr) que.push(node->children[j]);
                    }
                }
                result.push_back(temp);
            }
            return result;
        }
    };

    代码(Java):

    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 levelOrderSolution {
        public List<List<Integer>> levelOrder(Node root) {
            Deque<Node> que = new LinkedList<>();
            if (root != null) que.offer(root);
            List<List<Integer>> result = new ArrayList<>();
    ​
            while (!que.isEmpty()) {
                int size = que.size();
                List<Integer> temp = new ArrayList<>();
    ​
                for (int i = 0; i < size; i++) {
                    Node node = que.poll();
                    temp.add(node.val);
                    for (Node child : node.children) {
                        if (child != null) que.offer(child);
                    }
                }
    ​
                result.add(temp);
            }
            return result;
        }
    }

    分析:

    • 时间复杂度:O(N),N为树中的节点数

    • 空间复杂度:O(N),空间复杂度取决于队列的开销,最坏情况下为O(N)

  • 相关阅读:
    1203—颜文生—自动机实验
    11-11 优点缺点评价
    操作系统之银行家算法避免死锁
    操作系统之实验三 进程调度模拟程序
    操作系统之实验二作业调度模拟程序
    操作系统之实验二Step1-有序顺序表
    复利计算程序的单元测试
    操作系统之实验一 命令解释程序的编写
    复利计算程序之最新版
    《构建之法》第1.2.3章的感悟
  • 原文地址:https://www.cnblogs.com/wltree/p/15612133.html
Copyright © 2011-2022 走看看