剑指刷题 对称的二叉树

题目描述

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

 

思路： 先复制一个相同的 二叉树出来，

          然后将新的二叉树 转成 其镜像，

         判断两个二叉树是不是相等。  使用层次遍历的方法。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(pRoot==NULL)
            return true;
        TreeNode *newtree=copy(pRoot);
        Mirror(newtree);
        
        
        return comp(pRoot,newtree);
    }
    bool comp(TreeNode *pRoot,TreeNode *mRoot)
    {
        queue<TreeNode *> q1,q2;
        q1.push(pRoot);
        q2.push(mRoot);
        while(!q1.empty() )
        {
            pRoot=q1.front();
            mRoot=q2.front();
            if(pRoot==NULL ||mRoot ==NULL)
                return false;
            q1.pop();q2.pop();
            if(pRoot->val!=mRoot->val)
            {
                return false;
            }
            if(pRoot->left!=NULL)
            {   
                q1.push(pRoot->left);
                q2.push(mRoot->left);
            } 
            if(pRoot->right!=NULL)
            {
                q1.push(pRoot->right);
                q2.push(mRoot->right);
            }
        }
       if(q1.empty() && q2.empty()) 
            return true;
        return false;
    }
    TreeNode *copy(TreeNode *pRoot)
    {
        TreeNode *newtree=new TreeNode (pRoot->val);
        queue<TreeNode *> q1,q2;
        TreeNode *temp,*mRoot=newtree;
        q1.push(pRoot);
        q2.push(mRoot);
        while(!q1.empty())
        {
            temp=q1.front();
            mRoot=q2.front();
            q1.pop();q2.pop();
            if(temp->left!=NULL)
            {   
                mRoot->left= new TreeNode (temp->left->val);
                q1.push(temp->left);
                q2.push(mRoot->left);
            } 
            if(temp->right!=NULL)
            {
                mRoot->right=new TreeNode (temp->right->val);
                q1.push(temp->right);
                q2.push(mRoot->right);
            }
        }
        return newtree;
    }
    void Mirror(TreeNode *pRoot) {
        if(pRoot==NULL)
            return ;
        queue <TreeNode *> q;
        q.push(pRoot);
        TreeNode * root;
        while(!q.empty())
        {
            root=q.front();
            q.pop();
            TreeNode * temp=root->left;
            root->left=root->right;
            root->right=temp;
            if(root->left!=NULL)
                q.push(root->left);
            if(root->right!=NULL)
                q.push(root->right);
        }
    }
};