剑指 Offer 28. 对称的二叉树

一、题目 

题目链接：力扣

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

      1
    /    \
   2    2
  / \    / \
3  4 4  3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
    / \
  2   2
    \   \
    3    3

示例 1：

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

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

限制：

0 <= 节点个数 <= 1000

---

二、题解

1、思路

该问题可以转化为：两个树在什么情况下互为镜像？

如果同时满足下面的条件，两个树互为镜像：

1. 它们的两个根结点具有相同的值
2. 每个树的右子树都与另一个树的左子树镜像对称

其实我们可以理解为，根节点所的左子树和右子树具有这样的性质：

1. 左右子树根节点相等（不是根节点，是根节点的左子树根节点和根节点的右子树根节点）
2. 左子树结点左孩子 == 右子树对应结点右孩子
3. 左子树结点右孩子 == 右子树对应结点左孩子

算法流程：

首先是特殊情况，经过测试空树是对称二叉树。 

然后要么是递归，要么是迭代。

 🐹 递归（算是深度优先遍历，递归到最底层开始的）

递归的本质就是：判断上图中根节点的左子树L和右子树R两棵树是否互为镜像。 

递归函数用于递归判断参数一左孩子和参数二右孩子是否相等、参数一右孩子和参数二左孩子是否相等，第一次使用根节点调用该递归函数，刚好符合左右子树结点判断。

1. 左右子树根节点相等
2. 左子树结点左孩子 == 右子树对应结点右孩子
3. 左子树结点右孩子 == 右子树对应结点左孩子

🐹 迭代（层次遍历）（我估计下次还是想不起来，因为的确太绕了）

1. 递归改写为迭代，肯定要使用队列或者是栈。
2. 肯定要对比两个对应的结点是否相等、左孩子是否等右孩子、右孩子是否等左孩子。
3. 如果使用层次遍历方法，每次只拿出来一个结点是不行的。
4. 那么每次的压栈顺序、压栈个数就需要改变。
5. 因此每次需要拿出来两个结点，而且这两个结点还是对应的，即互为镜像的。
6. 第一组互为镜像的结点是谁呢？root->left和root->right！，不要将root入栈两次哦，没法理解。
7. 根节点左孩子和右孩子如栈后，然后弹栈判断两者是否相等。
8. 如果相等，说明满足镜像要求，继续判断其left左孩子是否等于right右孩子，left右孩子是否等于right左孩子。

🐹 题后思考： 

这个题一定要抓住一个思想：抓住根节点左子树和右子树互为镜像这一点，无论迭代还是递归，目的就是找两个对应结点对比，是否相等？左孩子等右孩子？右孩子等左孩子？

2、代码实现

🐹 递归

class Solution {
public:
    // 判断参数一和参数二两个结点是否相等，相等进行递归判断，不相等返回对应的值
    bool check(TreeNode* left, TreeNode* right)
    {
        // 都为空,说明递归匹配完毕，完全匹配
        if(left == NULL && right == NULL)return true;
        // 有一个为空,说明匹配失败
        if(left == NULL || right == NULL)return false;
        // 不为空,但不相等
        if(left->val != right->val)return false;
        else 
        {// 不为空，相等，接着判断其左右子孩子
            return check(left->left, right->right) && check(left->right, right->left);
        }

    }

    bool isSymmetric(TreeNode* root) {
        if(root == NULL)return true;
        
        // 直接判断根节点左右孩子是否满足：左孩子等于右孩子，左子树的
        return check(root->left, root->right);
    }
};

🐹 迭代（层次遍历）

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)return true;

        TreeNode* p = root;
        queue<TreeNode*> que;
        // 注意：无需将根节点入队两次，因为我们只关心左右子树是否互为镜像
        que.push(root->left);// 左孩子
        que.push(root->right);// 右孩子

        while(!que.empty())
        {
            TreeNode* tree1 = que.front();
            que.pop();
            TreeNode* tree2 = que.front();
            que.pop();

            // 比较两个值是否相等（互为镜像）
            if(tree1 == NULL && tree2 == NULL)continue;// 两个都为空，互为镜像，这里不能直接返回true，因为只能说明某个结点对应镜像，也就是还没判断完，截止条件是队列为空
            if(tree1 == NULL || tree2 == NULL)return false;// 只有一个为空，显然不是镜像
            if(tree1->val != tree2->val)return false;// 两个值不相等，同样不是镜像

            // 两个结点的值相等
            // 开始判断结点的左子树和右子树
            // 因为此处是循环，上面就在判断是否相等，因此直接将对应的结点入队即可循环判断
            que.push(tree1->left);
            que.push(tree2->right);

            que.push(tree1->right);
            que.push(tree2->left);
        }
        return true;
    }
};

3、复杂度分析

🐹 递归

时间复杂度：O(n)；

空间复杂度：O(n)。

🐹 迭代（层次遍历）

时间复杂度：O(n)；

空间复杂度：O(n)。

4、运行结果

🐹 递归

🐹 迭代（层次遍历）