描述

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

 

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

求解

    class Solution {
    private:
        // 翻转二叉树
        TreeNode *invertTree_recur(TreeNode *root) {
            if (root == nullptr) {
                return root;
            }
            // attention， 如果递归过程中直接对左右子树赋值，则破坏了原有的树结构
            // root->left = invertTree(root->right);
            // root->right = invertTree(root->left);
            invertTree_recur(root->left);
            invertTree_recur(root->right);
            std::swap(root->left, root->right);
            return root;
        }

        // 判断二叉树是否相等
        bool isSameTree_recur(TreeNode *p, TreeNode *q) {
            // p, q均为nullptr，相等
            if (!p && !q) {
                return true;
            }
            // 当前p, q均为非nullptr
            if (p && q) {
                if (p->val == q->val) {
                    // 且p, q节点值相等
                    // 如果p, q的左右子树均相等，则相等，否则不等
                    bool leq = isSameTree_recur(p->left, q->left);
                    bool req = isSameTree_recur(p->right, q->right);
                    return leq && req;
                } else {
                    // 若p, q节点值不相等，不等
                    return false;
                }
            }
            // p, q节点有一个为nullptr，不等
            return false;
        }

    public:
        // 利用逆转、 判断树是否相等两个辅助方法求解
        bool isSymmetric_withFun(TreeNode *root) {
            if (root == nullptr) {
                return true;
            }

            // 逆转左子树，然后与右子树比较是否相等
            auto rl = invertTree_recur(root->left);
            return isSameTree_recur(rl, root->right);
        }

        // 迭代求解
        bool check(TreeNode* p, TreeNode* q) {
            std::queue<TreeNode*> recordQ;
            recordQ.push(p);
            recordQ.push(q);
            while(!recordQ.empty()) {
                auto node1 = recordQ.front();
                recordQ.pop();
                auto node2  = recordQ.front();
                recordQ.pop();
                if(!node1 && !node2) {
                    continue;
                }
                if(!node1 || !node2 || (node1->val != node2->val)) {
                    return false;
                }

                recordQ.push(node1->left);
                recordQ.push(node2->right);
                recordQ.push(node1->right);
                recordQ.push(node2->left);
            }
            return recordQ.empty();
        }
        bool isSymmetric(TreeNode *root) {
            return check(root, root);
        }
    };