leecode429 | N叉树层序遍历 | dfs | 年过得真快

树的层次遍历，其实如果用迭代算是简单题吧
层序遍历，常规思路就是用队列，保存每次父节点的下一层子节点，然后在遍历这一层的子节点采用 队列的思想，先进后出
然后看到有的题解，采用 index 记录 “层号” 这样空间复杂度会低一些

/*
// Definition for a Node.
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) {
        std::vector<std::vector<int>> res;
        if(!root){
            return res;
        }
        function<void(Node*, int)> dfs = [&](Node* cur, int lev){
            if(!cur){
                return;
            }
            if(lev == res.size()){
                res.push_back({});
            }
            res[lev].push_back(cur->val);
            for(auto i : cur->children){
                dfs(i, lev + 1);
            }
        };
		// dfs(根节点，节点所在的层数）  倒置 从0开始
        dfs(root, 0);
        return res;
    }
};

#这里在详细讲一下吧， 发现function 函数还是用的少

#在遍历每一层的子节点，该层的lev 都是一样的，只有当该子节点还有孩子节点，则会继续-->先创建 {} 然后根据下标，将当前的节点插入，再判断该节点是否有孩子节点。
#这样完成递归

在贴一个用队列的思路，官方题解

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        if (!root) {
            return {};
        }

        vector<vector<int>> ans;
        queue<Node*> q;
        q.push(root);

        while (!q.empty()) {
            int cnt = q.size();
            vector<int> level;
            for (int i = 0; i < cnt; ++i) {
                Node* cur = q.front();
                q.pop();
                level.push_back(cur->val);
                for (Node* child: cur->children) {
                    q.push(child);
                }
            }
            ans.push_back(move(level));
        }

        return ans;
    }
};

前几天的每日一题都是树的遍历，所以大家都说是 “树”年
好遗憾，过年期间没有刷下来
总感觉自己并不属于这块料

还是不能打退堂鼓，不然越退越严重

还有就是时间过得真的好快，今年2024年，21研究生也要毕业了，22研究生明年也就毕业了

该说不说，我真是荒废时间的一把好手

希望，能抓住一些“xxx”尾巴吧

确实之前的一些路是需要尝试，当然也是需要付出代价的。

#过年，就是一场短暂又热闹的梦。

好了，该收心了