对称二叉树（递归加迭代，C++和python3）

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

例如，二叉树 [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,2,2,3,null,3]）这种情况，后来也考虑中序遍历是对称的，但是也是那个[1,2,2,3,null,3]这种情况，教训呀，真正的对称条件是：
1、两棵树的根节点相同；
2、每棵树的右子树和另一棵树的左子树对称；

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

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

/**
 * 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:
    //递归的方法解决这种问题
    //镜像树的条件：
    //1、两颗树的根节点相同
    //2、一棵树的左子树与另一棵树的右子树相同；
    bool isbalanceTree(TreeNode* t1,TreeNode* t2){
        if(!t1 && !t2){
            return true;
        }
        if(!t1 || !t2){
            return false;
        }
        return t1->val==t2->val && isbalanceTree(t1->left,t2->right)&&isbalanceTree(t1->right,t2->left);
    }
    bool isSymmetric(TreeNode* root) {
        return isbalanceTree(root,root);
    }
};

除了递归的方法，我们还可以用迭代法去解决这个问题，其中，我们运用队列这种数据结构，队列中连续的两个节点应该是相同的，他们的子树互为镜像，初始情况是队列中包含的是 root 以及 root。该算法的工作原理类似于 BFS，但存在一些关键差异。每次提取两个结点并比较它们的值。然后，将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时，或者我们检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。

/**
 * 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) {
        queue<TreeNode*>Q;
        Q.push(root);
        Q.push(root);
        while(!Q.empty()){
            TreeNode* t1=Q.front();
            Q.pop();
            TreeNode* t2=Q.front();
            Q.pop();
            if(!t1&&!t2){//两个都是null的时候continue;
                continue;
            }
            if(!t1||!t2){
                return false;
            }
            if(t1->val!=t2->val){
                return false;
            }
            Q.push(t1->left);
            Q.push(t2->right);
            Q.push(t1->right);
            Q.push(t2->left);
        }
        return true;
    }
};

python3

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        # 队列的方法
        if not root:
            return True
        Q = [root,root]
        while len(Q):
            t1 = Q.pop(0)
            t2 = Q.pop(0)
            if not t1 and not t2:
                continue
            if not t1 or not t2:
                return False
            if t1.val != t2.val:
                return False
            Q.append(t1.left)
            Q.append(t2.right)
            Q.append(t1.right)
            Q.append(t2.left)
        return True