代码随想录算法训练营第15天|102层序遍历|226.翻转二叉树 |101.对称二叉树

代码随想录算法训练营第15天|102层序遍历|226.翻转二叉树 |101.对称二叉树

102 层序遍历

题目链接/文章讲解/视频讲解：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

/**
 * 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);//如果结点不为空则把结点push到队列里

        vector<vector<int>>result;//建立一个动态的二维数组，里面存放每层的结点数据
        while(!que.empty())//但队列不为空时就一直执行，直到把二叉树里面的所有结点输出
        {
            //一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            int size=que.size();//把当前层的结点数存到临时size中
            
            vector<int>vec;//建立动态的一维数组来存放本层结点的数值

            for(int i=0;i<size;i++)//遍历本层结点
            {
                TreeNode* node=que.front();//把队列头元素复制一下
                que.pop();//弹出队列头元素
                vec.push_back(node->val);//把寄存的结点值给予动态一维数组里面

                //把结点的左右（下一层）继续push到队列里
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->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

/**
 * 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;//返回结果
    }
};

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

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

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

/**
 * 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:
        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 result = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return result;

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