day15|Leetcode:● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2

题目链接：102. 二叉树的层序遍历

代码

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>>result;
        queue<TreeNode*>que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
             vector<int>re;
             int size = que.size();
             for (int i = 0; i < size; i++) {
                TreeNode* cur = que.front();
                que.pop();
                re.push_back(cur->val);
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);              
             }
             result.push_back(re);
        } 
        return result;
    }
};

代码随想录：讲解链接

关键：栈和队列

栈存储后因为因为是先出左边的，就会不连续输出左右结点

队列是连续输出左右结点

---

题目链接：226. 翻转二叉树

思路：反转二叉树的每一个结点

为什么不用后序？

后序后面会遍历中间结点，等于反转了两次左子树，所以不能。

递归三部曲是什么?

代码随想录讲解:代码随想录

 这个除了后序都能用题目可以用

递归法：

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;
    }
};

迭代法（前序）

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()) {
            TreeNode* node = st.top();              // 中
            st.pop();
            swap(node->left, node->right);
            if(node->right) st.push(node->right);   // 右
            if(node->left) st.push(node->left);     // 左
        }
        return root;
    }
};

bfs

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right); // 节点处理
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

递归三部曲

确定返回类型和返回参数：返回类型为根结点，代表每个反转后的根，参数为根，从根开始递归

确定终止条件：当遍历到叶子结点的下一个结点时，为空相当于翻转过了

确定单层递归逻辑：我们看根结点直接，就是交换两边子树

---

题目链接：101. 对称二叉树

思路：

只能用后序遍历

前序会先输出结果不能。中序输出结果内测还每遍历完，后序等所有结果都完成才输出

二叉树是可以通过反转得到的， 所以二叉树的内层和外层相等，二叉树就是对称二叉树

递归三部曲是什么？

代码随想录讲解：代码随想录

递归法

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

递归三部曲

1.返回类型是bool类型，代表是对称二叉树，两个参数，比较左子树和右子树

2.终止条件是看现在遍历的这两个结点匹不匹配，明确结果的值

3.先求出外层匹不匹配，再求出内层匹不匹配，都匹配就真匹配