剑指offer.对称的二叉树（三种方法解决

题目：

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

思路：

通常我们有三种不同的二叉树遍历算法，二叉树的遍历其实就已经自带特殊性。先遍历根节点，再左，再右。所以我们可以再定义一个新的遍历方法，先遍历根节点，再右再左。与先序遍历的差别其实就是左右节点的遍历顺序。如果二叉树是对称的，那么这两种遍历的结果就会相同。但如果一个二叉树内都是一样的元素，我们其实就要考虑这个算法的鲁棒性够不够高。考虑过后我们要判断这种特殊情况就要在前序遍历的时候考虑nullptr指针。我们发现可以通过这样的方法来判断这种特殊情况从而判断二叉树是不是对称的。

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool traversal(struct TreeNode* Root1, struct TreeNode* Root2){
    if(Root1==NULL&&Root2==NULL){
        return true;
    }
    if(Root1==NULL||Root2==NULL){
        return false;
    }
    if(Root1->val!=Root2->val){
        return false;
    }
    return traversal(Root1->left, Root2->right)&&traversal(Root1->right, Root2->left);
}

bool isSymmetric(struct TreeNode* root){
    if(root==NULL){
        return true;
    }
    return traversal(root->left, root->right);
}

思路二：辅助栈

简单来说就是通过栈的存储来把一对一对的结点存进去再取出来查看是否相等，相等即对称

代码实现：
 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


bool isSymmetric(struct TreeNode* root){
    if(root==NULL){
        return true;
    }
    struct TreeNode** stack=(struct TreeNode**)malloc(sizeof(struct TreeNode*)*1000);
    int top=0;
    stack[top++]=root->right;
    stack[top++]=root->left;
    while(top!=0){
        struct TreeNode* left=stack[--top];
        struct TreeNode* right=stack[--top];
        if((!left&&right)||(left&&!right)){
            return false;
        }else if(!left&&!right){
            continue;
        }else if(left->val!=right->val){
            return false;
        }
        stack[top++]=right->left;
        stack[top++]=left->right;
        stack[top++]=right->right;
        stack[top++]=left->left;
    }
    return true;
}

思路三：队列（思路和上面那个一样，只是换了一个数据结构来存储罢了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


bool isSymmetric(struct TreeNode* root){
    if(root==NULL){
        return true;
    }
    struct TreeNode** queue=(struct TreeNode**)malloc(sizeof(struct TreeNode*)*1000);
    int head=0;
    int rear=0;
    queue[rear++]=root->left;
    queue[rear++]=root->right;
    while(head<rear){
        struct TreeNode* left=queue[head++];
        struct TreeNode* right=queue[head++];
        if((left&&!right)||(!left&&right)){
            return false;
        }else if(!left&&!right){
            continue;
        }else if(left->val!=right->val){
            return false;
        }
        queue[rear++]=left->left;
        queue[rear++]=right->right;
        queue[rear++]=left->right;
        queue[rear++]=right->left;
    }
    return true;
}