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

层序遍历  ​​​​​​​

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

题目链接/文章讲解/视频讲解：代码随想录

做题初始状态：不会

学完后想法：好绕

思路关键点：层序遍历方式即广度优先遍历，使用队列实现二叉树广度优先遍历

今日收获+学习时长：关于代码有很多详细注释，弥补了函数的定义等基础。学习时长，不详。

层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

使用队列实现二叉树广度优先遍历，动画如下：

代码如下：这份代码也可以作为二叉树层序遍历的模板

102.二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {//vector<vector<int>> levelOrder(TreeNode* root) 是一个函数的声明，它的作用是按层次遍历二叉树，并将每一层的节点值存储在一个二维向量中。
        queue<TreeNode*> que;//创建了一个名为 que 的队列，其中可以存储多个 TreeNode* 类型的指针。
        if(root != NULL) que.push(root);
        vector<vector<int>> result;//result用来表示一个矩阵或者二维数组。可以通过操作result来进行矩阵的初始化、访问、修改等操作。例如，可以使用result[i][j]来访问第i行第j列的元素。
        while (!que.empty()){
            int size = que.size();
            vector<int> vec;//声明了一个名为vec的变量，类型为vector<int>。，vector<int>表示存储整数类型的元素。通过使用vector<int>，我们可以方便地进行动态数组的操作，。可以使用vec.push_back()方法向vec中添加元素，使用vec[i]来访问第i个元素。
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for(int i = 0;i < size;i++){
                TreeNode* node = que.front();//表示从队列中取出队首元素
                que.pop();//将队首元素出队，即删除队首元素
                vec.push_back(node->val);//表示将节点的值添加到一个向量（或数组）vec的末尾。
                if (node->left) que.push(node->left);//如果节点的左孩子不为空，左孩子入队
                if (node->right) que.push(node->right);如果节点的右孩子不为空，右孩子入队
            }
            result.push_back(vec);//result是一个向量，vec是要添加的元素。通过调用push_back()函数，vec将被添加到result的末尾。
        }
        return result;//返回的结果即为该队列result
    }
};

107.二叉树的层次遍历II(opens new window)

class Solution {
public:
    vector<vector<int>> levelOrderBottom(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* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(), result.end()); // 在这里反转一下数组即可
        return result;

    }
};

199.二叉树的右视图(opens new window)

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

下列代码，详见代码随想录

637.二叉树的层平均值(opens new window)

429.N叉树的层序遍历(opens new window)

515.在每个树行中找最大值(opens new window)

116.填充每个节点的下一个右侧节点指针(opens new window)

117.填充每个节点的下一个右侧节点指针II(opens new window)

104.二叉树的最大深度(opens new window)

111.二叉树的最小深度

226.翻转二叉树

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

题目链接/文章讲解/视频讲解：代码随想录

做题初始状态：不会

学完后想法：思路有点清楚，还是模糊

思路关键点：（前序遍历，后序遍历均可做，但是中序不行）

                      1.如果树为空的话，就返回空节点root

                      2.交换节点的左右孩子

                      3.遍历节点的左子树，在遍历右子树

今日收获+学习时长：了解了反转二叉树的思路。学习时长，40min

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {//该题root只是节点的一个指代，不一定就是根节点
        if(root == NULL) return root;
        swap(root->left,root->right);//交换root的左右孩子
        invertTree(root->left);//遍历左子树
        invertTree(root->right);//遍历右子树
        return root;

    }
};

101.对称二叉树 2

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

题目链接/文章讲解/视频讲解：代码随想录

做题初始状态：不会

学完后想法：思路有点了解，还是模糊

思路关键点：后序遍历做                      

1. 首先排除空节点的情况
2.排除了空节点，再排除数值不相同的情况
3.此时就是：左右节点都不为空，且数值相同的情况
   此时才做递归，做下一层的判断

今日收获+学习时长：了解了对称二叉树的思路。学习时长，不详

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;
        return compare(root->left, root->right);
    }
};