day15 | 层序遍历、 226.翻转二叉树、101. 对称二叉树

目录：

解题及思路学习

层序遍历

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

使用队列实现二叉树广度优先遍历。

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.翻转二叉树

https://leetcode.cn/problems/invert-binary-tree/

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

!https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

思考：使用递归的方法，将左右节点对调。

class Solution {
public:
    void traversal (TreeNode* cur) {
        if (cur == NULL) return;
        traversal(cur->left);
        traversal(cur->right);
        TreeNode* tmp;
        tmp = cur->left;
        cur->left = cur->right;
        cur->right = tmp;
    }
    TreeNode* invertTree(TreeNode* root) {
       traversal(root);
       return root;
    }
};

或者使用层序遍历的方法。

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();
               if (node->left) que.push(node->left);
               if (node->right) que.push(node->right);
               TreeNode* tmp;
               tmp = node->left;
               node->left = node->right;
               node->right = tmp;
           }
       }
       return root;
    }
};

随想录代码

递归方法：

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) {
        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. 对称二叉树

https://leetcode.cn/problems/symmetric-tree/

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

!https://assets.leetcode.com/uploads/2021/02/19/symtree1.jpg

输入：root = [1,2,2,3,4,4,3]
输出：true

思考：判断左右孩子节点是否对称，所以可以传入两个值。

要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树）。

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

class Solution {
    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);
        return outside && inside;
    }
public:
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) return true;
        return compare(root->left, root->right);    
    }
};

迭代法：

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        queue<TreeNode*> que;
        que.push(root->left);   // 将左子树头结点加入队列
        que.push(root->right);  // 将右子树头结点加入队列
        
        while (!que.empty()) {  // 接下来就要判断这两个树是否相互翻转
            TreeNode* leftNode = que.front(); que.pop();
            TreeNode* rightNode = que.front(); que.pop();
            if (!leftNode && !rightNode) {  // 左节点为空、右节点为空，此时说明是对称的
                continue;
            }

            // 左右一个节点不为空，或者都不为空但数值不相同，返回false
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
                return false;
            }
            que.push(leftNode->left);   // 加入左节点左孩子
            que.push(rightNode->right); // 加入右节点右孩子
            que.push(leftNode->right);  // 加入左节点右孩子
            que.push(rightNode->left);  // 加入右节点左孩子
        }
        return true;
    }
};

复盘总结

个人反思

写递归的时候，注意三部曲：

1、确定递归函数的参数和返回值

2、确定终止条件

3、确定单层递归的逻辑