101. 对称二叉树

法一：一开始又是层序然后vector记录每一层再反转比较，但是不行，因为会有空结点，比如null,3,null,3这样反转的结果一样，但是不对称，所以null的地方用-1代替（不建议）
法二：搞清楚每种情况，同时操作两个结点！！初始递归也是将左右同时入队。每次循环弹出两个top比较，三种情况，全为空，直接continue；一个为空一个不为空，false；两个值不等，false。接下来就是入队的顺序非常重要，左的左和右的右先入队，保证它俩等下一起比较，然后是左的右和右的左入队。
法三：递归，也是同时操作两个结点，两个参数，左子结点和右子结点，判断三种情况，全空为true；然后递归判断左的左右的右和左的右右的左，返回两个递归判断式的与结果

/**
 * 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:
    //如果为空插入特殊值-1，这样是不可取的
    /*bool bfs(TreeNode* root){
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int sz = q.size();
            vector<int> vec;
            vector<int> fuzhu;
            while(sz--!=0){
                TreeNode* topNode = q.front();
                q.pop();
                if(topNode->left != nullptr){
                    q.push(topNode->left);
                    vec.push_back(topNode->left->val);
                }
                else{
                    vec.push_back(-1);
                }
                if(topNode->right != nullptr){
                    q.push(topNode->right);
                    vec.push_back(topNode->right->val);
                }
                else{
                    vec.push_back(-1);
                }
            }
            //一层遍历完再判断
            fuzhu = vec;
            reverse(fuzhu.begin(),fuzhu.end());
            if(vec != fuzhu) return false;
        }
        return true;
    }*/
    bool helper(TreeNode* l, TreeNode* r){
        if(l == nullptr && r==nullptr) return true;
        else if(l==nullptr || r == nullptr) return false;
        else if(l->val != r->val) return false;
        return helper(l->left,r->right) && helper(l->right,r->left);
    }

    bool isSymmetric(TreeNode* root) {
        //bfs记录层次的遍历即可，不要用vec判断，如果为空只能加入特殊值
        if(root == nullptr) return true;
        /*queue<TreeNode*> q;
        q.push(root->left);
        q.push(root->right);
        while(!q.empty()){
            TreeNode* leftNode = q.front();
            q.pop();
            TreeNode* rightNode = q.front();
            q.pop();
            //搞清楚条件和入队顺序即可
            if(leftNode == nullptr && rightNode == nullptr) continue;
            else if(leftNode == nullptr || rightNode == nullptr) return false;
            else if(leftNode->val != rightNode->val) return false;
            q.push(leftNode->left);
            q.push(rightNode->right);
            q.push(leftNode->right);
            q.push(rightNode->left);
        }
        return true;*/

        //递归，递归判断，和迭代其实是一样的，不要老觉得只能操作一个结点，对称这个必须同时操作两个结点
        return helper(root->left,root->right);
    }
};