LeetCode 429. N 叉树的层序遍历题解

429. N 叉树的层序遍历题解

题目来源：429. N 叉树的层序遍历

2022.04.08 每日一题

LeetCode 题解持续更新中GitHub仓库地址 CSDN博客地址

今天的题目就很简单了，同时 和树有关的一些知识点 可以看这里

具体代码以及注释如下

class Solution {
public:
    // 创建数组统计各个节点
    vector<vector<int>> res;

    void level(Node *root, int depth) {
        if (root == nullptr) return;
        // 如果 res 数组的长度要小于当前的深度
        // 就说明我们需要继续向 res 数组中放入当前的深度的节点，同时还记录了 当前的深度
        if (res.size() < depth) {
            res.push_back(vector<int>());
        }
        // 由于树的深度是从 1 开始的
        // 而数组的索引是从 0 开始的的
        // 因此要在 depth -1 的位置插入
        res[depth - 1].push_back(root->val);
        // 遍历子节点，将对应的值放入 相应的 res 数组之中
        for (Node *child: root->children) {
            level(child, depth + 1);
        }
    }

    vector<vector<int>> levelOrder(Node *root) {
        level(root, 1);
        return res;
    }
};

class Solution {

    // 创建数组统计各个节点
    public List<List<Integer>> res = new ArrayList<>();

    public void level(Node root, int depth) {
        if (root == null) return;
        // 如果 res 数组的长度要小于当前的深度
        // 就说明我们需要继续向 res 数组中放入当前的深度的节点，同时还记录了 当前的深度
        if (res.size() < depth) {
            res.add(new ArrayList<>());
        }
        // 由于树的深度是从 1 开始的
        // 而数组的索引是从 0 开始的的
        // 因此要在 depth -1 的位置插入
        res.get(depth - 1).add(root.val);
        // 遍历子节点，将对应的值放入 相应的 res 数组之中
        for (Node child : root.children) {
            level(child, depth + 1);
        }
    }

    public List<List<Integer>> levelOrder(Node root) {
        level(root, 1);
        return res;
    }
}

由于层次遍历的属性非常契合队列的特点，所以层次遍历用的是队列。

使用队列保存每一层的所有节点，把队列里的所有节点出队列，然后把这些出去节点各自的子节点入队列。以此来完成对每层的遍历。

class Solution {
public:
    vector<vector<int>> levelOrder(Node *root) {
        // 首先创建结果数组
        vector<vector<int>> res;
        // 如果树是空的，直接返回 空数组就行
        if (root == nullptr) return res;

        // 如果树不是空的，就创建一个队列，用于进行后续的层序遍历
        queue<Node *> qu;
        // 首先将根节点放入 栈中,以便后续迭代
        qu.push(root);

        while (!qu.empty()) {
            vector<int> temp;
            // 统计当前 队列的长度
            int len = qu.size();
            for (int i = 1; i <= len; ++i) {
                // 返回队列中的第一个节点，并从队列中删除当前节点
                Node *node = qu.front();
                qu.pop();
                // 向当前 数组中，加入相应的值
                temp.push_back(node->val);
                // 相应的值添加完成以后将其子节点们，依次放入队列中，进行下一次的迭代
                for (auto t: node->children) {
                    qu.push(t);
                }
            }
            // 当一层的节点遍历完成后，将得到的结果加入 结果数组 res 之中
            res.push_back(temp);
        }
        return res;
    }
};

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        // 首先创建结果数组
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        // 如果树是空的，直接返回 空数组就行
        if (root == null) {
            return res;
        }

        // 如果树不是空的，就创建一个队列，用于进行后续的层序遍历
        Queue<Node> queue = new LinkedList<Node>();
        // 首先将根节点放入 栈中,以便后续迭代
        queue.add(root);

        while (!queue.isEmpty()) {
            List<Integer> temp = new ArrayList<>();
            // 统计当前 队列的长度
            int len = queue.size();
            for (int i = 1; i <= len; ++i) {
                // 返回队列中的第一个节点，并从队列中删除当前节点
                Node node = queue.poll();
                // 向当前 数组中，加入相应的值
                temp.add(node.val);
                // 相应的值添加完成以后将其子节点们，依次放入队列中，进行下一次的迭代
                queue.addAll(node.children);
            }
            // 当一层的节点遍历完成后，将得到的结果加入 结果数组 res 之中
            res.add(temp);
        }
        return res;
    }
}