面试题28：对称的二叉树（C++）

题目地址：https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof/

题目描述

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

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

输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：

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

解题思路

DFS

(1)递归：利用递归的方法判断左右子树的值是否相同，具体分为左子树和右子树是否均为空，左子树和右子树是否完整，以及左子树和右子树的值是否相等几种情况，当左右子树相等时，比较左子树的左节点和右子树的右节点，以及左子树的右节点和右子树的左节点。

(2)非递归-栈：利用双指针p和q分别遍历左子树和右子树，其中指针p一直往左遍历，遍历左子树顺序为根节点->左节点->右节点，指针q一直往右，遍历右子树顺序为根节点->右节点->左节点

BFS

队列：利用队列进行迭代，因为二叉树为镜像，所以其中队列中连续的两个节点应该是相等的，要实现这一功能，需要我们装入队列元素时，先装入左子树的左节点，然后装入右子树的右节点，以及左子树的右节点和右子树的左节点，最后进行判断，当两个节点均为空时，此时说明满足镜像条件，则继续循环寻找镜像节点，否则当其中的一个节点为空时，返回false，说明此时不能构成镜像。

程序源码

递归

/**
 * 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 == nullptr) return true; //判空
        return isMirror(root->left, root->right);
    }
    bool isMirror(TreeNode* left, TreeNode* right)
    {
        if(left == nullptr && right == nullptr) return true; //左右子树均为空，返回true
        if(left == nullptr || right == nullptr) return false; //左右子树中有一个是空，则返回false
        if(left->val != right->val) return false; //左右子树值不相等，返回false
        return isMirror(left->left, right->right) && isMirror(left->right, right->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 == nullptr) return true;
        stack<TreeNode*> s1, s2;
        TreeNode* p = root;
        TreeNode* q = root;
        while (p != nullptr || !s1.empty()) {
            while (p != nullptr) {
                if (q == nullptr || p->val != q->val) return false; //左右子树其一为空或者两个指针当前节点值不相等
                s1.push(p);
                s2.push(q);
                p = p->left; 
                q = q->right; 
            }
            if (q != nullptr) return false;  //p为空，q不为空，即左右子树其一为空
            p = s1.top(); 
            s1.pop();
            q = s2.top(); 
            s2.pop();
            p = p->right;
            q = q->left;
        }
       return true; 
    }
};

队列

/**
 * 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 == nullptr) return true;
        queue<TreeNode*> que;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty())
        {
            TreeNode* p = que.front();
            que.pop();
            TreeNode* q = que.front();
            que.pop();
            if(p == nullptr && q == nullptr) continue;    
            if(p == nullptr || q == nullptr) return false;
            if(p->val != q->val) return false;
            que.push(p->left);
            que.push(q->right);
            que.push(p->right);
            que.push(q->left);
        }
        return true;
    }
};