Day16 LeetCode107. 二叉树的层序遍历 II 199.右视图 637. 层平均值 429. N 叉树的层序遍历 515. 在每个树行中找最大值 116.117.104.111.101.

题目：107. 二叉树的层序遍历 II - 力扣（LeetCode）

思路：

        先对二叉树进行层序遍历，最后把层序遍历的结果调用resverse函数进行翻转， 就得到了自底向上的遍历结果。

代码：

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;
        if(root ==  NULL) return res;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            res.push_back(vec);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

题目：199. 二叉树的右视图 - 力扣（LeetCode） 

思路：

        层序遍历，在遍历到每一层时将这层最后一个元素放入到res数组中，判断条件为i == size - 1

代码：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> res;
        if(root == NULL) return res;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                if(i == size - 1) res.push_back(node->val);// 将每一层的最后元素放入result数组中
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return res;
    }
};

 题目：637. 二叉树的层平均值 - 力扣（LeetCode）

思路：

        遍历每一层的时候计算每一层的平均数，定义一个变量sum，avg = sum / size；所以不能用while，得用for循环。

代码：

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        vector<double> res;
        if(root ==  NULL) return res;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            double sum = 0;
            for(int i = 0; i < size; i++){//得用for循环，size才能不变，如果用while(size--),循环结束后size就减为0了
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            res.push_back(sum / size);
        }
        return res;
    }
};

题目：429. N 叉树的层序遍历 - 力扣（LeetCode）

 思路：

        依然是层序遍历，只是每一个结点有多个孩子，那就把多个孩子都加入队列。

代码：

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        vector<vector<int>> res;
        if(root == NULL) return res;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            for(int i = 0; i < size; i++){
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for(int i = 0; i < node->children.size(); i++){
                     if(node->children[i]) que.push(node->children[i]);// 将节点孩子加入队列
                }  
            }
            res.push_back(vec);
        }
        return res;
    }
};

题目：515. 在每个树行中找最大值 - 力扣（LeetCode）

 思路：

        层序遍历到每一层时判断比较出最大值

代码：

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> res;
        if(root == NULL) return res;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            int maxValue = INT_MIN;
            for(int i = 0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                maxValue = maxValue > node->val ? maxValue : node->val;//在每一层中找到最大值     
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            res.push_back(maxValue);//一层遍历完毕后将最大值放进数组里
        }
        return res;
    }
};

题目：116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

 思路：

        在遍历到每一层时，将当前结点的next指针指向下一个结点

代码：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        Node* node = root;
        if(node == NULL) return node;
        que.push(node);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                Node* tmpnode = que.front();
                que.pop();
                if(i != size - 1){//前size-1个元素的next指针都有对应结点
                    tmpnode->next = que.front();//修改当前结点的next指针让其指向下一个结点，当前结点已经pop掉了，此时队列里的头结点就是当前结点的下一个结点，所以直接赋给tmpnode->next
                }else{
                    tmpnode->next = NULL;//只有遍历到最后一个结点 i == size - 1时，其next指针为NULL
                }
                if(tmpnode->left) que.push(tmpnode->left);
                if(tmpnode->right) que.push(tmpnode->right);
            }
        }
        return root;
    }
};

题目：117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）

 思路：

        和上题一样的思路

代码：

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

题目：104. 二叉树的最大深度 - 力扣（LeetCode） 

思路：

        定义一个变量depth记录深度，通过层序遍历的方法，只要每一层至少有一个元素就会把这层的元素放进队列里，队列就不为空，depth++，最后返回depth就是二叉树的最大深度。

代码：
 

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root == NULL) return 0;
        int depth = 0;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            depth++;
        }
        return depth;
    }
};

 题目：111. 二叉树的最小深度 - 力扣（LeetCode）

思路：

        使用层序遍历的方式来解决，思路是一样的。需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了，此时直接返回depth。如果其中一个孩子为空则不是最低点。

代码：

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root == NULL) return 0;
        int depth = 0;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            depth++;
            for(int i = 0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
                if(!node->left && !node->right) return depth;
            }
        }
        return depth;
    }
};

题目：101. 对称二叉树 - 力扣（LeetCode）

思路：

        采用递归的后序遍历方式 

具体分析见：代码随想录 (programmercarl.com)

代码：

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right){
        if(left == NULL && right != NULL) return false;
        else if(left != NULL && right == NULL) return false;
        else if(left == NULL && right == NULL) return true;
        else if(left->val != right->val) return false;
        bool outside = compare(left->left, right->right);//左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);//左子树：右、 右子树：左
        bool issame = outside && inside; //左子树：中、 右子树：中 （逻辑处理）
        return issame;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        bool res = compare(root->left, root->right);
        return res;
    }
};