leet101. 对称二叉树

题目：

给定一个二叉树，检查它是否是它自己的镜像（即，围绕它的中心对称）。

例如，这个二叉树 [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. 可以采用DFS方式或BFS方式遍历树，并对比节点值
2. 采用DFS方式时，对比根节点左右子树，交换其中一棵树的左右子树，对比对应的节点值
3. 采用BFS方式时，从两侧遍历同一层节点，比对对应节点值
   

代码：

1. DFS方式

2. class Solution(object):
       def isSymmetric(self, root):
           """
           :type root: TreeNode
           :rtype: bool
           """
           self.ret = True
           def dfsCmp(p,q):
               if self.ret:
                   if p and q:
                       # print "p:%d,q:%d"%(p.val,q.val)
                       if p.val != q.val:
                           self.ret = False
                           return self.ret
                       else:
                           q.left,q.right = q.right,q.left
                           dfsCmp(p.left,q.left)
                           dfsCmp(p.right,q.right)
                   elif p or q:
                       self.ret = False
   
           if root:
               if root.left and root.right:
                   dfsCmp(root.left,root.right)
               elif root.left or root.right:
                   return False
           return self.ret

   
   
   
3. BFS方式

4. class Solution(object):
       def isSymmetric(self, root):
           """
           :type root: TreeNode
           :rtype: bool
           """
           if not root:
               return True
           nodeLeft = [root.left]
           nodeRight = [root.right]
           while nodeLeft:
               nodeLeftNext = []
               nodeRightNext = []
               for i in range(len(nodeLeft)):
                   if nodeLeft[i] and nodeRight[i]:
                       if nodeLeft[i].val != nodeRight[i].val:
                           return False
                       else:
                           nodeLeftNext.append(nodeLeft[i].left)
                           nodeLeftNext.append(nodeLeft[i].right)
                           nodeRightNext.append(nodeRight[i].right)
                           nodeRightNext.append(nodeRight[i].left)
                   elif nodeLeft[i] or nodeRight[i]:
                       return False
               nodeLeft = nodeLeftNext
               nodeRight = nodeRightNext
           return True

   
   

思考：

1. 该问题用BFS方式更直接，更容易理解，BFS方式的代码在leetcode中由于100%的case
2. 采用DFS方式，在leetcode优于91%的case