LeetCode 101 对称二叉树的几种思路（Python实现）

对称二叉树

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

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

    1
   / \
  2   2
 / \ / \
3  4 4  3

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

    1
   / \
  2   2
   \   \
   3    3

思路1：使用层次遍历解决，如果每一层都是对称的 那么该二叉树为对称（正好先做的层次遍历，发现这里可以直接用同样思路做，把空节点用' '空格代替 以保证对称）

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

 class Solution:
     def isSymmetric(self, root: TreeNode) -> bool:
         if root == None:
             return True
         layer = [root]
         res = []
         while len(layer):
             this_res = []
             next_l = []
             for n in layer:
                 if n == ' ':
                     this_res.append(' ')
                     continue
                 this_res.append(n.val)
                 if n.left:
                     next_l.append(n.left)
                 else:
                     next_l.append(' ')
                 if n.right:
                     next_l.append(n.right)
                 else:
                     next_l.append(' ')
             for i in range(len(this_res)//2):
                 if this_res[i] != this_res[len(this_res)-i-1]:
                     return False
             layer = next_l

         return True

递归判断：

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

 class Solution:
     def judge(self, left, right):
         if left == None and right == None:
             return True
         if left != None and right == None:
             return False
         if left == None and right != None:
             return False
         if left.val != right.val:
             return False
         return self.judge(left.right, right.left) and self.judge(left.left, right.right)

     def isSymmetric(self, root: TreeNode) -> bool:
         if root == None:
             return True
         return self.judge(root.left, root.right)

迭代：

def isSymmetric(self, root):
        if not root:
            return True
        nodeList = [root.left,root.right]
        while nodeList:
            symmetricLeft = nodeList.pop(0)
            symmetricRight = nodeList.pop(0)
            if not symmetricLeft and not symmetricRight:
                continue
            if not symmetricLeft or not symmetricRight:
                return False
            if symmetricLeft.val != symmetricRight.val:
                return False
            nodeList.append(symmetricLeft.left)
            nodeList.append(symmetricRight.right)
            nodeList.append(symmetricLeft.right)
            nodeList.append(symmetricRight.left)
        return True