代码随想录算法训练营第十五天（补充题目） | 429.N叉树的层序遍历，515.在每个树行中找最大值，116.填充每个节点的下一个右侧节点指针，117.填充每个节点的下一个右侧节点指针II

和二叉树的层序遍历类似，就是层序遍历给每个子树的父节点选后继节点时候需要遍历节点结构体里面的节点数组，写法稍微有点不同

/*
// 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) {
        vector<vector<int>> res;
        queue<Node*> levelOrderQueue;

        if(root == NULL){
           return res;
        } 
        levelOrderQueue.push(root);

        while(!levelOrderQueue.empty()){
             int size = levelOrderQueue.size();
             vector<int> resVec;
             while(size--){
                   Node * node = levelOrderQueue.front();
                   levelOrderQueue.pop();
                   resVec.push_back(node->val);
                  for(auto i : node->children){
                        if(i != NULL){
                           levelOrderQueue.push(i);
                        }
                   }
             }
             res.push_back(resVec);
                       
        }
        return res;
    }
};

层序遍历找每一层的最大值，在每一层做快排，获取最大值，O(n(logn)^2 )。 可以在快排处优化，三元运算符找最大值，这样时间复杂度就是层序遍历的时间复杂度O(n)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    static bool comp(const int & a,const int & b){
            return a > b;
    }
    vector<int> largestValues(TreeNode* root) {
         vector<int> res;
         queue<TreeNode*> q;
        
         if(root == NULL){
            return res;
         }
         q.push(root);
         while(!q.empty()){
             int size = q.size();
             vector<int> resVec;

             while(size--){
                TreeNode * node = q.front();
                q.pop();
                resVec.push_back(node->val);
                if(node->left){
                   q.push(node->left);
                }
                if(node->right){
                   q.push(node->right);
                }
             }
             sort(resVec.begin(),resVec.end(),comp);
             res.push_back(resVec[0]);
         }
         return res;
    }
};

层序遍历，如果不谈优化解法的话，就这样了。。。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> levelOrderQueue;
        if(root == NULL){
           return root;
        }

        levelOrderQueue.push(root);
        while(!levelOrderQueue.empty()){
            int size = levelOrderQueue.size();
            vector<Node*> levelVec;

            while(size--){
                 Node* node = levelOrderQueue.front();
                 levelOrderQueue.pop();
                 levelVec.push_back(node);
                 if(node->left){
                   levelOrderQueue.push(node->left);
                 }
                 if(node->right){
                    levelOrderQueue.push(node->right);
                 }
            } 
            for(int i = 0;i< levelVec.size();i++){
                if(i + 1 < levelVec.size()){
                    levelVec[i]->next = levelVec[i+1];
                }else{
                    levelVec[i]->next = NULL;
                }
            }
        }
        
        return root;
    }
};

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> levelOrderQueue;
        if (root == NULL) {
            return root;
        }
        levelOrderQueue.push(root);
        while (!levelOrderQueue.empty()) {
            int size = levelOrderQueue.size();
            vector<Node*> resVec;
            while (size--) {
                Node* node = levelOrderQueue.front();
                levelOrderQueue.pop();
                resVec.push_back(node);
                if (node->left) {
                    levelOrderQueue.push(node->left);
                }

                if (node->right) {
                    levelOrderQueue.push(node->right);
                }
            }

            for (int i = 0; i < resVec.size(); i++) {
                if (i + 1 < resVec.size()) {
                    resVec[i]->next = resVec[i + 1];
                } else {
                    resVec[i]->next = NULL;
                }
            }
        }
        return root;
    }
};