算法刷题 Day 15 | 层序遍历 226.翻转二叉树 101. 对称二叉树

今日内容：

• 层序遍历 10
• 翻转二叉树
• 对称二叉树 2

层序遍历

看完本篇可以一口气刷十道题，试一试， 层序遍历并不难，大家可以很快刷了十道题。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0102.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86.html

Tips：感觉队列的实现比递归好写一些，要注意判断左右子节点非空后再入队列 

这个系列的题目有很多道，都是在此基础上做一些改动。

来吧，一口气打十个：

• 102.二叉树的层序遍历
• 107.二叉树的层次遍历II
• 199.二叉树的右视图
• 637.二叉树的层平均值
• 429.N叉树的层序遍历
• 515.在每个树行中找最大值
• 116.填充每个节点的下一个右侧节点指针
• 117.填充每个节点的下一个右侧节点指针II
• 104.二叉树的最大深度
• 111.二叉树的最小深度

我的题解：

/**
 * 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=NULL){
            que.push(root);
        }
        vector<vector<int>> result;
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            for(int i = 0;i < size;i++){
                TreeNode* temp = que.front();
                que.pop();
                vec.push_back(temp->val);
                // 一定要确定左右非空再入队列
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

226.翻转二叉树 （优先掌握递归）

这道题目 一些做过的同学 理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html

Tips：这道题比较简单，搞清楚用的是哪种遍历就行。

我的题解：

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL) {
            return root;
        }
        swap(root->left,root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

589. N 叉树的前序遍历

class Solution {
public:
    void travelsal(Node* root, vector<int>& vec){
        if(root == NULL){
            return;
        }
        vec.push_back(root->val);
        for(vector<Node*>::iterator iter = root->children.begin(); iter!=root->children.end(); iter++){
            travelsal(*iter,vec);
        }
    }
    vector<int> preorder(Node* root) {
        vector<int> result;
        travelsal(root,result);
        return result;
    }
};

101. 对称二叉树 （优先掌握递归）

先看视频讲解，会更容易一些。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html

Tips：最开始的想法是使用层序遍历+栈来做，后来发现这种做法只能判断值是不是轴对称的，而没法判断二叉树的结构是否也是轴对称。

因此采用以下这种方法，同时对左右子树进行后序遍历，并在过程当中进行比较。需要注意的是对指针为NULL的情况的处理，以及递归的终止条件的判断。

我的题解：

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 outer = compare(left->left,right->right);
        bool inner = compare(left->right,right->left);
        return outer && inner;
    } 

    bool isSymmetric(TreeNode* root) {
        if(root==NULL){
            return true;
        }
        return compare(root->left, root->right);
    }
};