对称的二叉树（Python and C++解法）

题目：

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/symmetric-tree

思路：

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

　　两个树互为镜像需要满足：它们的两个根结点具有相同的值；每个树的右子树都与另一个树的左子树镜像对称。

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

　　也可以迭代解决，首先我们引入一个队列，这是把递归改写成迭代的常用方法。初始化时需要把根节点入队 两次。每次提取两个结点并比较它们的值（如果树对称，队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像），然后将两个结点的左右子结点按对称的顺序插入队列中。当队列为空时，或者检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。

Python递归解法：

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        return self.check(root, root)

    def check(self, nodeP, nodeQ):
        if not nodeP and not nodeQ:  # 如果同时遇到空节点
            return True
        if not nodeP or not nodeQ:  # 因为上面一次判断，已经排除!nodeP and !nodeQ的情况
            return False
        if nodeP.val == nodeQ.val:
            return self.check(nodeP.left, nodeQ.right) and self.check(nodeP.right, nodeQ.left)
        return False

Python迭代解法：

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        return self.check(root, root)

    def check(self, nodeP, nodeQ):
        queue = []
        queue.append(nodeP)
        queue.append(nodeQ)

        while len(queue):
            nodeP = queue.pop(0)  # python的pop默认返回列表最后一个元素
            nodeQ = queue.pop(0)
            if not nodeP and not nodeQ:
                continue
            if (not nodeP or not nodeQ) or nodeP.val != nodeQ.val:
                return False
            queue.append(nodeP.left)
            queue.append(nodeQ.right)

            queue.append(nodeP.right)
            queue.append(nodeQ.left)
        return True

C++递归解法：

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
    bool check(TreeNode *nodeP, TreeNode *nodeQ) {
        if (!nodeP && !nodeQ)
            return true;
        if (!nodeP || !nodeQ)
            return false;
        if (nodeP->val == nodeQ->val)
            return check(nodeP->left, nodeQ->right) && check(nodeP->right, nodeQ->left);
        return false;  // 前面都是if,此处必须有返回
    }

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

C++迭代解法：

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
    bool check(TreeNode *nodeP, TreeNode *nodeQ) {
        queue<TreeNode*> que;
        que.push(nodeP);  que.push(nodeQ);  // 同时入队两个父节点
        while (!que.empty()) {
            nodeP = que.front(); que.pop();  // 取出第一个父节点，C++的pop()只删除不返回
            nodeQ = que.front(); que.pop();  // 取出第二个父节点
            if (!nodeP && !nodeQ)
                continue;  // 当前节点均为空，继续判断其他节点
            // 在上面if的基础上，如果节点不同时为空，或节点不相等，则树不对称
            if ((!nodeP || !nodeQ) || (nodeP->val != nodeQ->val))
                return false;
            que.push(nodeP->left);    que.push(nodeQ->right);
            que.push(nodeP->right);   que.push(nodeQ->left);
        }
        return true;
    }

    bool isSymmetric(TreeNode* root) {
        return check(root, root);  // 参数变成两个
    }
};