leetcode_101. Symmetric Tree 对称树， 判断一棵二叉树是否对称，递归方法

题目：

Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree [1,2,2,3,4,4,3] is symmetric:

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

But the following [1,2,2,null,3,null,3] is not:

    1
   / \
  2   2
   \   \
   3    3

题意：

判断一棵二叉树是否对称

代码：

# 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 leafisSymmetric(self, leftnode, rightnode):
        """
        :type root: TreeNode
        :rtype: bool
        """
        
        if leftnode == None and rightnode == None :
            return True
        else :
            if leftnode != None and rightnode != None :
                return leftnode.val == rightnode.val and self.leafisSymmetric(leftnode.left,rightnode.right) and self.leafisSymmetric(leftnode.right,rightnode.left)
            else :
                return False
    
    def  isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root == None :
            return True
        else :
            return self.leafisSymmetric(root.left, root.right)

笔记：

参考 http://blog.csdn.net/feliciafay/article/details/18397183

自己用非递归方法写了两遍代码，都超时了，悲剧

一、

def getlevelnodelist(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """

        if root == None or root != None and root.left == None and root.right == None :
            return True
        else :
            rootlist = []
            if root.left == None :
                rootlist.append(TreeNode(1000000000))
            else :
                rootlist.append(root.left)
            if root.right == None :
                rootlist.append(TreeNode(1000000000))
            else :
                rootlist.append(root.right)
            
            
            while 1 :
                length = len(rootlist)
                for i in range(length/2) :
                    if rootlist[i].val != rootlist[length-1-i].val :                 #判断是否对称
                        return False
                
                temp_root = []    #寻找下一层节点
                count = 0          #记录该层空节点
                for x in rootlist :
                    if x.val == 1000000000 :
                        count = count + 1
                        temp_root.append(TreeNode(1000000000))       #空节点左孩子
                        temp_root.append(TreeNode(1000000000))          #空节点右孩子
                    else :
                        if x.left == None :
                            temp_root.append(TreeNode(1000000000))
                        else :
                            temp_root.append(x.left)
                        if x.right == None :
                            temp_root.append(TreeNode(1000000000))
                        else :
                            temp_root.append(x.right)
                    if count == length :    #全是空节点
                        return True
                rootlist = temp_root

二、

def getlevelnodelist(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
    
        rootlist = [root]
        rootvaluelist = [root.val]


        while 1 :
            count = 0
            temproot = []
            leafcount = 0
            for x in rootlist :
                if x == None :
                    count += 1
                    temproot.append(None)
                    temproot.append(None)
                    rootvaluelist.append(100000000)
                    rootvaluelist.append(100000000)
                else :
                    if x.left == None :
                        leafcount += 1
                        temproot.append(None)
                        rootvaluelist.append(100000000)
                    else :
                        temproot.append(x.left)
                        rootvaluelist.append(x.left.val)
                    if x.right == None :
                        leafcount += 1
                        temproot.append(None)
                        rootvaluelist.append(100000000)
                    else :
                        temproot.append(x.right)
                        rootvaluelist.append(x.right.val)
            if count == len(rootlist) :
                return rootvaluelist
            if leafcount == len(rootlist)*2 :
                return rootvaluelist
            rootlist = temproot
    
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        
        
        if root == None or root != None and root.left == None and root.right == None :
            return True
        else :
            #node_num = self.getnodecount(root)
            
            nodelist = self.getlevelnodelist(root)
            
            node_num = len(nodelist)
            
            #print nodelist
            #print node_num
            
            sum_node = 0
            level = 0
            while sum_node < node_num :
                sum_node = sum_node + 2**level
                level += 1
            
            level = level-1
            
            for i in range(1,level) :
                start = 2**i-1
                end = 2*start
                while start < end :
                    if nodelist[start] != nodelist[end] :
                        return False
                    start += 1
                    end -= 1
            return True