【每日力扣29】对称二叉树

一、题目[LeetCode-101]

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

示例 1：

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

输出：true

示例 2：

 

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

输出：false

提示：

• 树中节点数目在范围 [1, 1000] 内
• -100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？

二、思路

观察题意知，一棵树为对称树，当且仅当根节点的左右儿子值相等（如果有的话），且左右子树互相对称。而左右子树互相对称的递归体现就是，对左子树的任一节点往左儿子进行递归遍历，则结果应与对右子树的对应位置的节点的右儿子进行递归遍历的结果一致。

因此，开始先取根节点的左右子节点，首先判断根节点的左右儿子的值是否相等，若不相等则返回false。之后便可以写递归子方法判断这两棵子树是否对称。

由两棵树的对称性的性质，重载isSymmetric作为递归子算法，参数为两个数节点。同理判断两个节点是否为空的退化情况，判断完递归基（两个节点同时为空，返回true；两个节点其一为空，返回false）后，开始判断两个节点均不为空的情况。这里则递归判断t1左儿子与t2右儿子这一对是否满足以及t1右儿子与t2左儿子这一对是否满足，在子树都满足了对称的情况下，最后判断t1的值是否与t2相同，相同则返回true。这里是先往下递归再对“当前递归”节点作出判断操作，因此为后序遍历。

/**
 * 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 isSymmetric(TreeNode* root) {
        if(root->left == nullptr && root->right == nullptr)//根节点不存在子节点的退化情况
            return true;
        if((root->left != nullptr && root->right == nullptr) || (root->right != nullptr && root->left == nullptr) )//根节点的左右子节点仅存在一个的退化情况
            return false;
        else//当根节点具有两个子节点
            return isSymmetric(root->left, root->right);
    }
    bool isSymmetric(TreeNode* t1, TreeNode* t2){
        if(t1 == nullptr && t2 == nullptr)//两个节点均为空节点的退化情况
            return true;
        if((t1 == nullptr && t2 != nullptr) || (t2 == nullptr && t1 != nullptr))//两个节点只有一个为空节点的退化情况
            return false;
        else//当两个节点均不为空时
        {
            if(isSymmetric(t1->left, t2->right)&&isSymmetric(t1->right, t2->left))//先递归判断子树的节点是否满足对称。
                return t1->val == t2->val;
            else return false;
        }
    }
};

 

三、官方题解（来源：力扣（LeetCode））

方法一：递归

如果一个树的左子树与右子树镜像对称，那么这个树是对称的。

 

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

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

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

我们可以实现这样一个递归函数，通过「同步移动」两个指针的方法来遍历这棵树，p 指针和 q 指针一开始都指向这棵树的根，随后p 右移时，q 左移，p 左移时，q 右移。每次检查当前 p 和 q 节点的值是否相等，如果相等再判断左右子树是否对称。

class Solution {
public:
    bool check(TreeNode *p, TreeNode *q) {
        if (!p && !q) return true;
        if (!p || !q) return false;
        return p->val == q->val && check(p->left, q->right) && check(p->right, q->left);
    }

    bool isSymmetric(TreeNode* root) {
        return check(root, root);
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/symmetric-tree/solution/dui-cheng-er-cha-shu-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

假设树上一共 n 个节点。

• 时间复杂度：这里遍历了这棵树，渐进时间复杂度为 O(n)。
• 空间复杂度：这里的空间复杂度和递归使用的栈空间有关，这里递归层数不超过 n，故渐进空间复杂度为 O(n)。

方法二：迭代

「方法一」中我们用递归的方法实现了对称性的判断，那么如何用迭代的方法实现呢？首先我们引入一个队列，这是把递归程序改写成迭代程序的常用方法。初始化时我们把根节点入队两次。每次提取两个结点并比较它们的值（队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像），然后将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时，或者我们检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。

class Solution {
public:
    bool check(TreeNode *u, TreeNode *v) {
        queue <TreeNode*> q;
        q.push(u); q.push(v);
        while (!q.empty()) {
            u = q.front(); q.pop();
            v = q.front(); q.pop();
            if (!u && !v) continue;
            if ((!u || !v) || (u->val != v->val)) return false;

            q.push(u->left); 
            q.push(v->right);

            q.push(u->right); 
            q.push(v->left);
        }
        return true;
    }

    bool isSymmetric(TreeNode* root) {
        return check(root, root);
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/symmetric-tree/solution/dui-cheng-er-cha-shu-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

• 时间复杂度：O(n)，同「方法一」。
• 空间复杂度：这里需要用一个队列来维护节点，每个节点最多进队一次，出队一次，队列中最多不会超过 n 个点，故渐进空间复杂度为 O(n)。

四、学习心得

递归代码的优化

①两个条件语句下&&与||的使用顺序的有效利用可以简化代码

对于退化情况的判断，官方解法仅仅用简短的两个if语句搞定。

if (!p && !q) return true;

if (!p || !q) return false;

因为第一个情况的条件是!q与!p同时满足，之后直接return结果了。所以当进行到第二个条件语句的时候，自然不会!p与!q同时满足，满足第二个条件语句的情况一定是!p与!q二者有且只有一个满足。因此大可放心直接return false。这样写来非常简洁。

按照官解的启示，笔者的代码同样也可简化

if(root->left == nullptr && root->right == nullptr)           	return true;
if((root->left != nullptr && root->right == nullptr) || (root->right != nullptr && root->left == nullptr) )
return false;

第二行大可放心直接更改为：

if(root->left == nullptr || root->right == nullptr )
return false;

得到了很美观的改进。

同时root->left == nullptr也可直接写作!root->left

②笔者代码中对于根节点的左右子节点的判断与其他节点对称性判断是同理的，也可以并入子算法的范畴中，不需要在主算法里花费这么多行来判断根节点的左右子节点。

因此主方法直接写一行即可：

bool isSymmetric(TreeNode* root) {
            return isSymmetric(root->left, root->right);
    }