leetcode NO.101 对称二叉树

递归法：

类似后序遍历，只是左子树遍历左边节点的时候相应的右子树要遍历右边的节点，相当于是从外侧的节点遍历到里侧的节点，顺序和序遍历一样都是左右中

class Solution {
public:
    bool comp(TreeNode* left, TreeNode* right) {
        if (left == nullptr && right != nullptr)
            return false;
        else if (right == nullptr && left != nullptr)
            return false;
        else if (left == nullptr && right == nullptr)
            return true;
        else if (right->val != left->val)
            return false;
        return  comp(left->left, right->right) && comp(left->right, right->left);
    }
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr)
            return true;
        bool result = comp(root->left, root->right);
        return result;
    }
};

迭代法：

这里我用的是层序遍历，也可以用其他的方法做。我这里是把每一层的节点遍历一遍，用双端队列把这一层的节点储存起来，之后再依次检查队首和队尾的数值（空节点用了一个大的负数代替）

class Solution {
public:
   
    bool isSymmetric(TreeNode* root) {
        queue<TreeNode*> w;
        if (root)
            w.push(root);
        while (!w.empty()) {
            int size = w.size();
            deque<int> m;
            TreeNode* node;
            for (int i = 0; i < size; i++) {
                node = w.front();
                if (node->left) {
                    w.push(node->left);
                    m.push_back(node->left->val);
                } else if (node->left == nullptr)
                    m.push_back(-10000);
                if (node->right) {
                    w.push(node->right);
                    m.push_back(node->right->val);
                } else if (node->right == nullptr)
                    m.push_back(-10000);
                w.pop();
            }
            for (int j = 0; j < size; j++) {
                if (m.front() != m.back())
                    return false;
                m.pop_front();
                m.pop_back();
            }
        }
        return true;
    }
};