（写给未来遗忘的自己）

102.二叉数的层序遍历（从上到下）

题目：

代码：

class Solution {  
public:  
    vector<vector<int>> levelOrder(TreeNode* root) {  
        vector<vector<int>> result;  
        queue<TreeNode*> node;  
  
        if (root == nullptr) {  
            return result;  
        }  
  
        node.push(root);  
  //这个是一层执行一次
        while (!node.empty()) {  
            int node_size = node.size();  
            vector<int> layer_result;  
  //处理横着一列的数据
            for (int i = 0; i < node_size; i++) {  
                TreeNode* root_t = node.front();  
                node.pop();  
                layer_result.push_back(root_t->val);  
  
                if (root_t->left != nullptr) {  
                    node.push(root_t->left);  
                }  
  
                if (root_t->right != nullptr) {  
                    node.push(root_t->right);  
                }  
            }  
  
            result.push_back(layer_result);  
        }  
  
        return result;  
    }  
};

思路：

 107.二叉树的层序遍历Ⅱ（从下往上遍历）

题目：

代码： 

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>>result;
        std::queue<TreeNode*>node;
        std::stack<vector<int>>result_uptodown;
        if(root==nullptr) return result;
        node.push(root);

        while(!node.empty()){
            int layer_size=node.size();
            vector<int>layer_result;
            for(int i=0;i<layer_size;i++){
                TreeNode* root_t=node.front();
                node.pop();
                layer_result.push_back(root_t->val);
                if(root_t->left!=nullptr) node.push(root_t->left);
                if(root_t->right!=nullptr) node.push(root_t->right);
            }
           result_uptodown.push(layer_result);
        }
        while(!result_uptodown.empty()){
            result.push_back(result_uptodown.top());
            result_uptodown.pop();
        }
        return result;
    }
};

思路：

整体思路和上面一样。但是我们需要的是从下到上的。

stack实现的是先进后出的机制。所以我们在第一个案例的实现的时候一层的数vector<int>layer_result的数据不要直接push_back在result中，经过一个stack<vector<int>>,这样最下层的最先弹出。 

 199.二叉树的右视图：

题目：

代码：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
    vector<int>result;
    std::queue<TreeNode*>node;
    if(root==nullptr) return result;
    node.push(root);
    while(!node.empty()){
        int layer_size=node.size();
        vector<int>layer_result;

        for(int i=0;i<layer_size;i++){
            TreeNode* root_t=node.front();
            node.pop();
            layer_result.push_back(root_t->val);
            if(root_t->left!=nullptr) node.push(root_t->left);
            if(root_t->right!=nullptr) node.push(root_t->right);
        }
        result.push_back(layer_result[layer_size-1]);
    }
    return result;

    }
};

思路：

主代码的逻辑一致，只是最后的结果存入只要层的vector的最后一位。

637.二叉树的层平均值

题目：

代码：

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double>restlt;
        std::queue<TreeNode*>node;
        node.push(root);
        while(!node.empty()){
            int layer_size=node.size();
            double sum=0;
            for(int i=0;i<layer_size;i++){
                TreeNode*root_t=node.front();
                node.pop();
                sum=sum+root_t->val;
                if(root_t->left!=nullptr) node.push(root_t->left);
                if(root_t->right!=nullptr) node.push(root_t->right);

            }
            restlt.push_back(sum/layer_size);
        }
        return restlt;

    }
};

思路：

在for循环中累加和，然后加入result的时候求平均值。

429.N叉树的层序遍历

题目：

代码：

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>>result;
        queue<Node*>node;
        if(root==nullptr) return result;
        node.push(root);

        while(!node.empty()){
            
            int layer_size=node.size();
            vector<int>layer_result;
            for(int i=0;i<layer_size;i++){
                 Node* root_t=node.front();
                 node.pop();
                 layer_result.push_back(root_t->val);
                 for(auto it:root_t->children){
                    node.push(it);
                 }

            }
            result.push_back(layer_result);
        }
        return result;
        
    }
};

思路：

N叉树和二叉树的区别在于存储子节点的方式为：

vector<node*>children

所以在存储新的数据进去的时候不能用原来的方式，需要换成for循环遍历vector

//二叉数
if(root_t->left!=nullptr) node.push(root_t->left);
if(root_t->right!=nullptr) node.push(root_t->right);

//N叉树
for(auto it:root_t->children){
                    node.push(it);
                 }

 515.在每一个树行中找到最大值

题目：

代码： 

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int>result;
        queue<TreeNode*>node;
        if(root==nullptr) return result;
        node.push(root);

        while(!node.empty()){
            
            int layer_size=node.size();
            int layer_max=std::numeric_limits<int>::min();
            for(int i=0;i<layer_size;i++){
                 TreeNode* root_t=node.front();
                 node.pop();
                if(root_t->val>layer_max){
                    layer_max=root_t->val;
                }
                 if(root_t->left!=nullptr) node.push(root_t->left);
                 if(root_t->right!=nullptr) node.push(root_t->right);
                
                 }
                result.push_back(layer_max);
            }
        return result;   
    }
        
};

思路和知识点：

每一行找最大值

初始值的定义最小值：

std::numeric_limits<int>::min();

116.填充每一个节点的下一个右侧节点指针：

题目：

代码：

class Solution {
public:
    Node* connect(Node* root) {
        Node* result=root;
        std::queue<Node*>node;
        if(root==nullptr) return result;
        node.push(root);
        while(!node.empty()){
            int layer_size=node.size();
            for(int i=0;i<layer_size;i++){
                Node* root_first=node.front();
                node.pop();
                Node* root_second=node.front();
                if(root_first->left!=nullptr) node.push(root_first->left);
                if(root_first->right!=nullptr) node.push(root_first->right);
                
                if(i==layer_size-1){
                    root_first->next=NULL;
                }else {
                    root_first->next=root_second;
                }
            }
        }

        return result;
        
    }
};

思路：

整体的层次遍历和上面的处理一样。

重写代码在于怎么实现指向下一个的语句。

Node* root_first=node.front();
node.pop();
Node* root_second=node.front();

if(i==layer_size-1){
   root_first->next=NULL;
 }else {
  root_first->next=root_second;
     }

队列中取完当前元素后的第一个元素就是我们需要next指向的，所以我们只取使用，不弹出。

117.填充每一个节点的下一个右侧节点指针Ⅱ

题目：

这道题和上一道题的区别在于一个是完全二叉树，一个不是。但是代码的逻辑没有按照这个做刻意的处理，所以代码一样。 

104.二叉树的最大深度

题目：

代码：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int result=0;
        std::queue<TreeNode*>node;
        if(root==nullptr) return result;
        node.push(root);
        while(!node.empty()){
            int layer_size=node.size();

            for(int i=0;i<layer_size;i++){
                TreeNode* root_t=node.front();
                node.pop();
                if(root_t->left!=nullptr) node.push(root_t->left);
                if(root_t->right!=nullptr) node.push(root_t->right);
            }
            result++;
        }
        return result;

    }
};

111.二叉树的最小深度：

题目：

 代码：

class Solution {  
public:  
    int minDepth(TreeNode* root) {  
        int result = 1; 
        std::queue<TreeNode*> nodeQueue;  
        if (root == nullptr) return 0; 
        nodeQueue.push(root); 
        while (!nodeQueue.empty()) {  
            int layerSize = nodeQueue.size(); 
            for (int i = 0; i < layerSize; i++) {  
                TreeNode* currentNode = nodeQueue.front();   
                nodeQueue.pop(); 
                if (currentNode->left == nullptr && currentNode->right == nullptr)  return result; 
                if (currentNode->left != nullptr)   nodeQueue.push(currentNode->left);  
                if (currentNode->right != nullptr)   nodeQueue.push(currentNode->right);   
            }   
            result++;  
        }  
        return result;
    }  
};

思路：

最浅就是：一个节点没有任何的子节点的时候就是最浅