[leetcode日记]101.对称二叉树

题目

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

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

进阶：

你可以运用递归和迭代两种方法解决这个问题吗？

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/symmetric-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

如果一个树的左子树与右子树镜像对称，那么这个树是对称的。之前有写过一道题，求一个二叉树地镜像对称。然后比较镜像对称后地二叉树和源二叉树是否相等就可以了。但是这样会有一种“杀鸡焉用牛刀”的感觉。这里就按部就班用递归和迭代的方法分别求解就可以了。

先说递归的思路，递归就是写一个函数check（node1，node2）来判断node1指向的树和node2指向的树是否镜像对称。如果同时满足下面的条件，两个树互为镜像：它们的两个根结点具有相同的值或均为空；每个树的右子树都与另一个树的左子树镜像对称。其中第一点可以用if语句进行判断，第二点就用到了递归。有了这个思路以后应该不难写出递归代码。

然后是非递归的思路。一般而言，把递归转化成非递归都是要用到队列或者栈进行操作。这里应该是用队列和栈都可以，分别对应的是深度优先和广度优先的比较。我采用了队列的形式，所以是进行广度优先的比较。每次将需要比较的两个元素进队，然后弹出时比较两个元素的节点值，并将他们不为空的对应子节点入队。如此操作直到队列为空。

代码1——递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool check(struct TreeNode* pleft,struct TreeNode *pright) {
    if (!pleft && !pright) {    //两者均为空
        return true;
    }
    if (!pleft || !pright) {    //只有一者为空
        return false;
    }
    if (pleft->val != pright->val) {    //两者均不为空但是值不相等
        return false;
    }
    return check(pleft->left,pright->right) && check(pleft->right,pright->left);
}

bool isSymmetric(struct TreeNode* root){
    if (root == NULL) {
        return true;
    } 

    return check(root->left,root->right);
}

运行结果

代码2——迭代

#define MAXLEN 100

struct TreeNode g_queue[MAXLEN];
int g_len = 0;
int g_head = 0;
int g_tail = 0;

void AddQueue(struct TreeNode *node) {	//将节点加入队列
    if (g_tail < MAXLEN) {
        g_queue[g_tail] = *node;
        g_len++;
        g_tail++;
    }
    if (g_tail == MAXLEN) {		//这是一个循环队列，容量为MAXLEN
        g_tail = 0;
    }
}

struct TreeNode* GetQueue() {	//队列的pop操作
    struct TreeNode *node = NULL;
    if (g_head < MAXLEN) {
        node = &g_queue[g_head];
        g_head++;
        g_len--;
    }
    if (g_head == MAXLEN) {
        g_head = 0;
    }
    return node;
}

bool isSymmetric(struct TreeNode* root){	
    if (root == NULL) {
        return true;
    }
    g_head = 0;
    g_len = 0;
    g_tail = 0;
    AddQueue(root);
    AddQueue(root);		//一次进栈两个root，以获得函数的兼容性
    while (g_len != 0) {	//一次获取两个节点，期待它们相等并且
        struct TreeNode *node1 = GetQueue();
        struct TreeNode *node2 = GetQueue();
        if (node1->val != node2->val) {
            return false;
        }
        if (node1->left != NULL) {
            if (node2->right != NULL) {
                AddQueue(node1->left);
                AddQueue(node2->right);
            } else {
                return false;
            } 
        }
        if (node1->right != NULL) {
            if (node2->left != NULL) {
                AddQueue(node1->right);
                AddQueue(node2->left);
            } else {
                return false;
            } 
        }
    }
    return true;
}

运行结果

复杂度分析

两种方法对树的每个节点都只需要进行O（1）的操作，所以综合起来的时间复杂度只有O（n），对于空间复杂度，两者也都是O(n)。

感谢大家的支持和点赞。