LC101 对称二叉树（三种解法：递归、迭代、层序遍历后比较字符）

题目：

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

 

例如，二叉树 [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. 方案一：递归
   通过递归解决的思路是：传入根节点的左右结点分别为 p 和 q，递归得检查p->left与q->right或是p->right与q->left结点；
   结束条件：
   1）当新传入的p和q同时为NULL时，表示这个对称位置都为NULL，return true；
   2）当新传入的p 或 q其中之一为NULL是，表示这个对称位置上元素并不对称，return false；
   递归部分：
   检查（p->val == q->val）&& check(p->left,q->right)&& check(p->right,q->left);

2. 方案三：层序遍历检查每一层的数组是否为回文数组
   思路是：对二叉树进行层序遍历，使用一个pair存储结点与层数，当遍历到下一层时，检查当前层存储的数组，是否为回文；

3. 方案二：迭代（比方案三要好，与方案一思路类似）
   利用队列，每次取出队首的两个元素，同样，每次压入队首两个元素对应的4个元素，注意方向左右， 右左

1）首先判断取出的队首元素是否为空（或者两个中的一个为空），判断是否返回
2）如果都不为空，比较他们的值
3）别忘了将新的元素压进来；

代码1：递归

/**
 * 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 check_node(TreeNode* p, TreeNode* q)
    {
        if(p == NULL && q == NULL)
            return true;
        if(p == NULL || q == NULL)  // 因为已经排除了都为NULL情况，所以如果其中一个为空表示不对称
            return false;
        return p->val == q->val && check_node(p->left,q->right) && check_node(p->right,q->left);
    }
    bool isSymmetric(TreeNode* root) {
        // 递归方法：
        return check_node(root, root);
    }
};

代码3：层序遍历后比较回文数组

class Solution {
public:
    bool check_temp(vector<int>& temp)
    {
        for(int i = 0; i < temp.size()/2; i++){
            if(temp[i] != temp[temp.size() - i - 1])
                return false;
        }
        // for(int i : temp)            测试部分
        //     cout << i << '\t';
        // cout <
        return true;
    }
    
    bool isSymmetric(TreeNode* root) {
        // 思路： 层序遍历，判断每一层的元素是否为对称的；
        queue<pair<TreeNode*,int>> q_data;  
        q_data.push({root, 1}); // 存储结点的队列
        vector<int> temp;   // 用来存储每一层元素的数组
        int before = 1;     // 表示当前层数的变量；

        while(!q_data.empty())
        {
            if(q_data.front().second != before){    // 首先判断：是否进入新的一层
                before = q_data.front().second;     // 如果进入：更新层数，检查当前temp，清空temp；
                bool ret = check_temp(temp);
                if(ret == false)
                    return false;
                else {
                    temp.clear();
                }
            }
            // 判断当前结点是否为空，如果为空代表这个位置无数字
            // 不为空代表这是一个正常的结点：元素填入temp、左右子结点填入q_data
            if(q_data.front().first != NULL){
                temp.push_back(q_data.front().first->val);
                
                if(q_data.front().first->left){// 左子树不为空：添加左节点到队列
                    q_data.push({q_data.front().first->left,q_data.front().second + 1});
                }
                if(q_data.front().first->left == NULL){// 左子树为空：添加NULL到队列
                    q_data.push({q_data.front().first->left,q_data.front().second + 1});
                }
                if(q_data.front().first->right){   
                    q_data.push({q_data.front().first->right,q_data.front().second + 1});
                }
                if(q_data.front().first->right == NULL){
                    q_data.push({q_data.front().first->right,q_data.front().second + 1});
                }
                
            } 
            
            // 当前结点为空：将INT_MIN标志存入temp
            else {  
                temp.push_back(INT_MIN);
            }
            
            q_data.pop();
        }
        if(check_temp(temp))
            return true;
        else 
            return false;
    }
};

代码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:

    bool isSymmetric(TreeNode* root) {
        // 迭代方法：
        queue<TreeNode*> q_data;
        if(root == NULL)
            return true;
        q_data.push(root->left);
        q_data.push(root->right);
        
        while(!q_data.empty())
        {
            TreeNode* x1 = q_data.front();  // 取出队首两个元素
            q_data.pop();
            TreeNode* x2 = q_data.front();
            q_data.pop();

            // 判断队首两个元素是否是对称的，先判断是否为NULL，再判断值的问题；
            if(x1 == NULL && x2 == NULL)
                continue;
            if(x1 == NULL || x2 == NULL)
                return false;
            if(x1->val != x2->val)
                return false;
            // 将当前两个元素的子节点依次入队
            q_data.push(x1->left);
            q_data.push(x2->right);
            q_data.push(x1->right);
            q_data.push(x2->left);
        }
        return true;
    }
};