剑指 Offer 28. 对称的二叉树

思路1：

#include<iostream>
using namespace std;

  
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

//全部使用递归  比较原则是 先新建一个树 然后将这个树翻转 再比较两个树是否相同
//显然效率较低

class Solution {
    TreeNode* root2;
    TreeNode* mirrorTree(TreeNode* root) {
        if(root!=NULL)
        {
            mirrorTree(root->left);
            mirrorTree(root->right);
            swap(root->left,root->right);//后序遍历直接交换 秒杀
        }
        return root;
    }
    TreeNode* copyTree(TreeNode*root1,TreeNode* root2)
    {
        if(root1!=NULL)
        {
            root2=new TreeNode(root1->val);//建立此节点
            root2->left=copyTree(root1->left,root2->left);//递归建立左边
            root2->right=copyTree(root1->right,root2->right);//递归建立右边
            return root2;//返回root2
        }
        else return NULL;
    }
    bool isSame(TreeNode* root1,TreeNode*root2)//递归思想 抽取局部进行分析
    {//分为3种情况
        if(root1!=NULL&&root2!=NULL)//左右指针都不为空
        {
            if(root1->val==root2->val)//左右值相等
            {//再看看他们左子树右子树是不是一样
                return isSame(root1->left,root2->left)&&isSame(root1->right,root2->right);
            }
            else return false;//值都不相等 那没得比了
        }
        else if(root1==NULL&&root2==NULL)//两个都为空 那就是一样的
        {
            return true;
        }
        else return false;//一个空一个不为空也没得比了
    }
public:
    bool isSymmetric(TreeNode* root) {
        root2=copyTree(root,root2);//新建一个树
        root2=mirrorTree(root2);//翻转这个树
        return isSame(root,root2);//比较两个树是否相同
    }
};

思路2：

#include<iostream>
#include<queue>
using namespace std;


struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
//思路 利用队列对每层进行比较
class Solution {
    TreeNode* ed = new TreeNode(-1000);
    int a[10000] = { 0 };//记录每层数据
    int count1 = 0;//记录每层个数
    bool judge = true;//记录是否所有层都相等
public:
    bool isSymmetric(TreeNode* root) {
        queue<TreeNode*> q;
        if (root == NULL)
        {
            return true;
        }
        else
        {
            q.push(root);
            q.push(ed);//加入终止节点  代表这一层已经结束
            while (!q.empty())
            {
                TreeNode* m = q.front();
                q.pop();
                if (m != NULL)
                {
                    if (m == ed && q.size() != 0)//如果这层结束 且队列里面也没有节点
                    {
                        for (int i = 0; i < count1 / 2; i++)//比较这层的数字是否对称
                        {
                            if (a[i] != a[count1 - i - 1])
                            {
                                judge = false;
                                return false;//有一层不相等就结束了
                            }
                        }
                        count1 = 0;
                        q.push(ed);//为下一层加入尾节点
                    }
                    else
                    {//没结束就直接加 没问题
                        a[count1++] = m->val;
                        q.push(m->left);
                        q.push(m->right);
                    }
                }
                else a[count1++] = -10000;//为空节点时也要设置一个值 因为可能是 空 4 4 空结构也是正确的
            }
            return judge;
        }
    }
};
TreeNode* set(TreeNode* root)
{
    int m;
    cin >> m;
    if (m != 0)
    {
        root= new TreeNode(m);
        root->left = set(root->left);
        root->right = set(root->right);
        return root;
    }
    else return NULL;
}
int main()
{
    TreeNode* root = new TreeNode(0);
    root=set(root);
    Solution a;
    cout<<a.isSymmetric(root);
}

思路3：

#include<iostream>
using namespace std;

  
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
//双指针思路  用两个指针 分别移动 进行比较  一下取两个节点  相互对称 
class Solution {
    bool isSame(TreeNode* l,TreeNode* r)
    {
        if(l==NULL&&r==NULL)//两个指针都为空时说明一样
        {
            return true;
        }
        else if(l!=NULL&&r!=NULL)//都不为空时
        {
            if(l->val==r->val)//值一样 比较儿子是否一样
            {//儿子是左指针的左儿子和右指针的右儿子 并且 左指针的右儿子和右指针的左儿子都得一样
                return isSame(l->left,r->right)&&isSame(l->right,r->left);
            }
            else return false;//值不一样 那就一定不一样
        }
        else return false;//一个为空一个不为空 一定不一样
    }
public:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)//根节点为空 那没得比了
        {
            return true;
        }
        else //不为空 判断两边子树是否一样
        {
            return isSame(root->left,root->right);
        }
    }
};

思路4：

#include<iostream>
#include<queue>
using namespace std;

  
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
    queue <TreeNode*> l,r;//左队列从左到右遍历  右队列从右到左遍历
    bool judge=true;//判断是否相同
    bool isSame(TreeNode* left,TreeNode* right)
    {
        l.push(left);
        r.push(right);
        while(!l.empty()||!r.empty())//应该是或  如果两个有一个不为空就要继续比下去 这样才能看出
        //区别
        {
            auto m=l.front();
            auto n=r.front();
            l.pop();
            r.pop();
            if(m!=NULL&&n==NULL||m==NULL&&n!=NULL)//一个空一个不为空 false
            {
                judge=false;
                return false;
            }
            else if(m!=NULL&&n!=NULL)//都不为空
            {
                if(m->val!=n->val)//看值 值不相等 为false
                {
                    judge=false;
                    return false;
                }
                else //值相等 再进一步判断子树
                {
                    l.push(m->left);
                    l.push(m->right);
                    r.push(n->right);
                    r.push(n->left);
                }
            }
            //都为空 那么可以进一步比较
        }
        return judge;
    }
public:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)//根节点为空 那就对称
        {
            return true;
        }
        else //不然就看两边子树是否一样
        {
            return isSame(root->left,root->right);
        }
    }
};