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

102.层序遍历

题目链接：https://leetcode.cn/problems/binary-tree-level-order-traversal/
文章讲解：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
视频讲解：https://www.bilibili.com/video/BV1GY4y1u7b2

思路

用队列来实现，首先将根节点加入队列，然后用一个size来表示每一层的长度，size=que.size()即可，用一个临时一维数组存储每一层的元素值，首先，队列出队一个元素，将该元素放入临时数组，然后判断有无左右子节点，若有，则入队，每循环完一层，就将该元素加入到结果数组中

代码实现

/**
 * 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;
        vector<vector<int>> res;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size --){
                TreeNode* cur = que.front();
                vec.push_back(cur -> val);
                que.pop();
                if(cur -> left != NULL){
                    que.push(cur -> left);
                }
                if(cur -> right != NULL){
                    que.push(cur -> right);
                }
            }
            res.push_back(vec);
        }
        return res;
    }
};

226.翻转二叉树

题目链接：https://leetcode.cn/problems/invert-binary-tree/
文章讲解：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html
视频讲解：https://www.bilibili.com/video/BV1sP4y1f7q7
状态：不会

思路

首先，我们需要明白递归的三要素

1. 确定递归函数的参数和返回值
2. 确定终止条件
3. 确定单层递归的逻辑

关于二叉树的问题，解题前一定要想明白究竟是什么遍历

在本题中，我们要去确定遍历方式是什么，递归还是非递归，递归里的前中后序遍历是哪个？这里，我就先学习了递归的实现。
那么，本题的终止条件为什么是节点为空就返回呢？
答：我们顺着遍历方式去深度搜索，当节点为空时，即能明白节点为叶节点，就可以进行交换了
后序遍历应该怎么写？为什么中序遍历就不可以了呢？

代码实现

注意：swap函数可以用来交换指针

/**
 * 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://leetcode.cn/problems/symmetric-tree/
文章讲解：https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html
视频讲解：https://www.bilibili.com/video/BV1ue4y1Y7Mf
状态：不会

思路

首先，我们需要明白我们不是来比较左右孩子的，我们是来比较左右子树的。
确定终止条件，我们要从上往下走，终止条件就是会遇到的各种不用继续深度的情况，千万不要非要走到最下面的判断，容易脑子混乱
我们可以将二叉树分为外侧和内侧，到根节点的左右节点，就比较它们的外侧内侧是否相同，不满足终止条件，则继续递归下去比较外侧和内侧

代码实现

/**
 * 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 campare(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 = campare(left -> left, right -> right);
        bool inside = campare(left -> right, right -> left);
        bool isName = outside && inside;
        return isName;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        return campare(root -> left, root -> right);
    }
};

收获

关于层序遍历，一般用一个一维数组和一个二维数组来搞，循环的size是每一层队列的长度
在做二叉树的时候，要首先确定什么遍历方式
递归的三要素
swap可以用来交换指针