每天一道LeetCode-----判断二叉树左右两边是否成镜像关系

Symmetric Tree

原题链接Symmetric Tree

判断给定的二叉树和自身是否成镜像关系

以二叉树根节点为中心做垂线，两边正好是相反的才叫镜像，以两个值为2的节点leftNode和rightNode为例

需要满足

• leftNode->val == rightNode->val;
• leftNode->left->val == rightNode->right->val;
• leftNode->right->val == rightNode->left->val;

当然，使用递归是比较方便的，从根节点开始向下，逐个比较，即如果满足leftNode->val == rightNode->val，那么，需要让他们的子节点也同样满足镜像规则，只需要递归

isSymmetric(leftNode->left, rightNode->right) && 
isSymmetric(leftNode->right, rightNode->left);

每次进入isSymmetric函数时，参数的两个节点都来自根节点的两边，所以可以判断是否是镜像

代码如下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        return !root || isSymmetric(root->left, root->right);  
    }
private:
    bool isSymmetric(TreeNode* leftNode, TreeNode* rightNode)
    {
        if(!leftNode && !rightNode) return true;
        if((leftNode && !rightNode) || (!leftNOde && rightNode))    return false;
        if(leftNode->val != rightNode->val) return false;
        return isSymmetric(leftNode->left, rightNode->right) && isSymmetric(leftNode->right, rightNode->left);
    }
};

---

迭代法只是简单的用队列维护遍历到的节点，思路都一样

代码如下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(!root)   return true;
        queue<TreeNode*> lq, rq;
        lq.push(root->left);
        rq.push(root->right);
        while(!lq.empty() && !rq.empty())
        {
            TreeNode* leftNode = lq.front();
            TreeNode* rightNode = rq.front();
            lq.pop();
            rq.pop();
            if(!leftNode && !rightNode) continue;
            if((leftNode && !rightNode) || (!leftNode && rightNode))    return false;
            if(leftNode->val != rightNode->val) return false;
            lq.push(leftNode->left);
            rq.push(rightNode->right);
            lq.push(leftNode->right);
            rq.push(rightNode->left);
        }
        return lq.empty() && rq.empty();
    }
};

---

递归还是比较容易写出的，需要注意镜像是在根节点两边对称，而不是每个节点的左右子树对称，递归时传入的参数要注意