LeetCode——对称二叉树

LeetCode——对称二叉树

题目描述：
给定一个二叉树，检查它是否是镜像对称的。

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

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

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

解题方法：
这里提供递归和迭代两种方法求解。

递归法：
我们要判断一棵树是否为对称二叉树，我们就要检查根节点的左子树和右子树是否对称，也就是判断根节点下左子树和右子树是否为镜像。
往下推就是看两棵树的左子树和右子树是否对称。
因此有两个条件：
1.两个树的根节点有相同的值。
2.每个树的左子树都和另一个树的右子树镜像对称。

这就构成了一个递归，我们定义一个check函数来判断两棵子树是否对称，该函数有两个参数，一个是左节点，一个是右节点。当两个节点的值不相同时我们直接返回false，如果相同则判断这两个节点的左子树是否和另个一节点的右子树对称。
我们在主函数中调用它，参数为两个根节点（root）。

迭代法：
我们定义一个队列，根据队列先进先出的顺序，我们将两个跟节点放入队列，然后进入一个循环，判断循环是否为空，如果不为空则执行以下操作：将两个节点出队列，判断他们的值是否相等，如果不相等直接返回false结束循环；如果相等则按照p-left，q-right，q-left，p-right的顺序进队列（按照这个顺序的原因就是之前说过的条件2）。如果最后队列为空，说明整个树是对称的，返回true。

这里提供Java和Python的代码。

递归法Java代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return isParallel(root,root);
    }
    public boolean isParallel(TreeNode leftTree,TreeNode rightTree){
        if(leftTree == null && rightTree == null){
            return true;
        }
        if(leftTree == null || rightTree == null){
            return false;
        }
        if(leftTree.val != rightTree.val){
            return false;
        }
        return isParallel(leftTree.left,rightTree.right) && isParallel(rightTree.left,leftTree.right);
    }
}

LeetCode测试结果：

递归法Python代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.check(root, root)
    
    def check(self, leftTree, rightTree):
        if leftTree is None and rightTree is None:
            return True
        if leftTree is None or rightTree is None:
            return False
        if leftTree.val != rightTree.val:
            return False
        return self.check(leftTree.left, rightTree.right) and self.check(rightTree.left, leftTree.right)

LeetCode测试结果：

迭代法Java代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root){
        return check(root,root);
    }
    public boolean check(TreeNode p,TreeNode q){
        Queue queue = new LinkedList<TreeNode>();
        queue.offer(p);
        queue.offer(q);
        while(!queue.isEmpty()){
            p = (TreeNode) queue.poll();
            q = (TreeNode) queue.poll();
            if (p == null && q == null){
                continue;
            }
            if ((p == null || q == null) || (p.val != q.val)){
                return false;
            }

            queue.offer(p.left);
            queue.offer(q.right);

            queue.offer(q.left);
            queue.offer(p.right);
        }
        return true;
    }
}

LeetCode测试结果：

迭代法Python代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
from queue import Queue

class Solution(object):
    def isSymmetric(self, root):
        return self.check(root, root)

    def check(self, p, q):
        que = Queue(maxsize=0)
        que.put(p)
        que.put(q)
        while not que.empty():
            p = que.get()
            q = que.get()
            if p is None and q is None:
                continue
            if (p is None or q is None) or (p.val != q.val):
                return False
            que.put(p.left)
            que.put(q.right)
            que.put(q.left)
            que.put(p.right)
        return True

LeetCode测试结果：