101. 对称二叉树easy

又是被简单题折磨的一天

时空复杂度都是O(n)

我一开始想的迭代：利用栈类似中序遍历比较，但是有很多特殊情况判断错误，所以提交了好多次，缝缝补补加了很多条件判断才成功

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        stack<TreeNode*>stackl;
        stack<TreeNode*>stackr;
        TreeNode*pl=root->left;
        TreeNode*pr=root->right;
        while((!stackl.empty()&&!stackr.empty())||pr||pl){
            if(!pl&&pr||pl&&!pr)
                return false;
            while(pl&&pr){
                stackl.push(pl);
                pl=pl->left;
                stackr.push(pr);
                pr=pr->right;
                if(!pl&&pr||pl&&!pr)
                return false;
            }
            pl=stackl.top();
            stackl.pop();
            pr=stackr.top();
            stackr.pop();
            if(pl->val!=pr->val)
                return false;
            pl=pl->right;
            pr=pr->left;
        }
        return true;
    }
};

方法一：递归
先找递归思路，怎样才算是镜像对称呢？两个节点的值相同，且左子树等于另一个右子树，右子树等于另一个左子树，这就找到递归的思路了。那么结束条件很明显。

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

方法二：迭代
利用队列，从根节点向下判断

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
    queue<TreeNode*>de;
    de.push(root);
    de.push(root);//先放两次根节点
    while(!de.empty()){
        TreeNode*l=de.front();
        de.pop();
        TreeNode*r=de.front();
        de.pop();
        if(!l&&!r)
       		continue;//存在此情况因为入队列并不判断指针是否为空
        if(!l&&r||l&&!r||l->val!=r->val)
            return false;
        de.push(l->right);
        de.push(r->left);
        de.push(l->left);
        de.push(r->right);
    }
    return true;
    }
};

哎。。。。。。。