【Leetcode热题100——宽度优先搜索-二叉树】Leetcode 101. 对称二叉树

Leetcode 101. 对称二叉树

题目描述：给定一个二叉树，检查它是否是镜像对称的。

宽度优先搜索（迭代）的解法：
思路１：使用队列，利用宽度优先搜素对二叉树进行层级遍历，把每一层节点的值val放入一个数组中，然后判断该层节点是否为镜像，如果不是就返回false。这里当某个节点为null时，这里的处理是将INT_MAX放入数组中。
思路2：仍然使用队列，利用镜像对称的性质。加入队列时，将一颗树加入两次，然后就是将第一次放入的树的节点加入队列，将另第二次放入的树的右子树加入队列，按照镜像对称的性质，这两个节点应该相同，如果不相同就不满足镜像对称。

递归的解法：
和上面的思路2一样，只是换成了递归的写法。

代码：

//1. 宽度优先搜索解法——思路1
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (nullptr == root) {
            return true;
        }

        //1. 定义队列，先将头节点放入其中
        queue<TreeNode*> Queue;
        Queue.push(root);

        //2. while队列不空
        while (!Queue.empty()) {
            vector<int> level;

            //3. for上一层节点拓展出下一层节点
            int Size = Queue.size();
            for (int i = 0; i < Size; ++i) {
                auto node = Queue.front();
                Queue.pop();
                if (nullptr != node->left) {
                    Queue.push(node->left);
                    level.push_back(node->left->val);
                } else {
                    level.push_back(INT_MAX);
                }
                if (nullptr != node->right) {
                    Queue.push(node->right);
                    level.push_back(node->right->val);
                } else {
                    level.push_back(INT_MAX);
                }
            }
            
            //如果该层不对称,返回false
            if (!(isMirror(level))) {
                return false;
            }
        }
        
        return true;
    }

    //判断二叉树某层节点是否镜像对称
    bool isMirror(vector<int>& level) {
        for (int i = 0, j = level.size() - 1; i < j; ++i, --j) {
            if (level[i] != level[j]) {
                return false;
            }
        }
        return true;
    }
};

//2. 宽度优先搜索解法——思路2
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (nullptr == root) {
            return true;
        }

        //1. 初始化队列,将头节点放入队列
        queue<TreeNode*> Queue;
        Queue.push(root);
        Queue.push(root);

        //while队列不空
        while (!Queue.empty()) {
            auto leftNode = Queue.front();
            Queue.pop();
            auto rightNode = Queue.front();
            Queue.pop();

            if (nullptr == leftNode && nullptr == rightNode) {
                continue;
            }
            if (nullptr == leftNode || nullptr == rightNode || leftNode->val != rightNode->val) {
                return false;
            }
            
            Queue.push(leftNode->left);
            Queue.push(rightNode->right);
            Queue.push(leftNode->right);
            Queue.push(rightNode->left);
        }
        return true;
    }

};

//3. 递归解法

```cpp
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        //递归的调用
        return helper(root, root);
    }

    //递归的定义
    bool helper(TreeNode* leftNode, TreeNode* rightNode) {
        //递归的出口
        if (!leftNode && !rightNode) {
            return true;
        }
        if (!leftNode || !rightNode) {
            return false;
        }

        //递归的拆解
        return leftNode->val == rightNode->val && helper(leftNode->left, rightNode->right) && helper(leftNode->right, rightNode->left);
    }
};