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

文档讲解：代码随想录

视频讲解：讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历_哔哩哔哩_bilibili

听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树_哔哩哔哩_bilibili

新学期要从学习二叉树开始！ | LeetCode：101. 对称二叉树_哔哩哔哩_bilibili 

---

第十四天，进行到二叉树第二部分了，层序遍历，实际上就是广度优先搜索，想成功，先发疯哈哈哈哈~

102.二叉树的层序遍历

感受：最开始写了这题之后又一口气用这份模板打了力扣的十道题，不得不说真的快会背了。还是以102题为例，剩下的题以此为基础写就不细说了。

思路：用广度优先搜索，或者叫迭代法。由于队列是先进先出的顺序，这符合我们一层一层遍历的逻辑，因此我们选择队列作为辅助数据结构来解题。

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;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            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);
        }
        return result;
    }
};

226. 翻转二叉树

递归直接秒了。本题使用前序遍历。

/**
 * 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. 对称二叉树

对称二叉树实质是让我们判断一个根节点下的左右子树是否可以反转，是否可以反转意味着我们需要判断对应的结点元素是否相等。并不难，但需要注意的是遍历顺序只适合使用后序遍历，当然不是严格意义上的后序遍历，我们需要通过递归函数的返回值去判断比较左右子树的内侧和外侧结点的值是否相等。

/**
 * 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);
    }
};

总结：总计用时4h二叉树懵懵懂懂，又是辛苦开肝的一天，要成功先发疯！