101. 对称二叉树

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

我的解答：

/**
 * 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) {
        TreeNode* p=root->left;
        TreeNode* q=root->right;
        if(p==NULL&&q==NULL)
            return true;
        else if(p==q)
        {
            isSymmetric(p);
            isSymmetric(q); 
        }
        else
            return false;
    }
};

1.思路错误，题目要求树是中心对称轴对称。2.判断是否为空，可以简化。

改进1.0 递归法：

思路：使用递归算法，递归调用f(root,root)->f(root->left,root->right)和f(root->right,root->left。

class Solution {
public:
    bool f(TreeNode* p,TreeNode* q){
        //p,q均为空
        if(!p&&!q)
            return true;
        //p,q一个为空
        if(!p||!q)
            return false;
        //p与q相等，且对称 返回true
        return (p->val==q->val)&&f(p->left,q->right)&&f(p->right,q->left);
    }

    bool isSymmetric(TreeNode* root) {
        return f(root,root);
    }
};

注：不可以为了减少递归次数，从f(root->left,root->right)开始递归，因为报错（目前不知道为什么）。
时间复杂度O(n)，空间复杂度O(n)（递归栈占用空间）。

改进2.0 迭代法：

思路：递归改成迭代，使用一个队列。每次入队p->left ,q->right和p->right ,q->left。两两出队，对比。

队列的使用：
定义：queue <type> q;
取队头：q.front();
出队：q.pop();//返回null
入队：q.push();
队空：q.empty();

class Solution {
public:
    bool f(TreeNode* u,TreeNode* v){
        //创建一个队列
        queue<TreeNode*> q;
        //入队
        q.push(u);q.push(v);
        //队非空时循环
        while(!q.empty()){
            //分别取第一个（应该立即出队）和第二个元素
            u=q.front();q.pop();
            v=q.front();q.pop();
            //若u、v均空，进入下一个循环
            if(!u&&!v) continue;
            //若u、v一个为空或不相等，返回false
            if((!u||!v)||(u->val!=v->val)) return false;
            //若u、v相等，进入下一阶段
            
            q.push(u->left);q.push(v->right);
            q.push(v->left);q.push(u->right);
        }
        return true;
    }

    bool isSymmetric(TreeNode* root) {
        return f(root,root);
    }
};

时间复杂度O(n)，空间复杂度O(n)（递归栈占用空间）。
数据结构：队列。