leetcode#101. Symmetric Tree

description

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
Note:
Bonus points if you could solve it both recursively and iteratively.

Thinking

没想到什么好方法，只想到了遍历一遍树，得到层序的序列，然后将序列根据每层的节点个数切片，对每个切片分析是否镜像对称。
一边写着代码，突然发现，不用得到最后序列再切片了。因为每次得到的是一层的序列，所以可以直接拿去判断了。

Code (iteratively)

# 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):
    serial = []
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root == None:
            return True
        self.serial = [root.left, root.right]
        return self.getSerial()

    def getSerial(self):
        res = self.check()
        temp = []
        flag = False #标志一层内有无非空节点
        if res == False:
            return res
        else:
            for i in self.serial:
                if not i == None:
                    flag = True
                    temp += [i.left, i.right]
                else:
                    temp += [None, None]
            if flag == False: #这层全是空节点 
                return True
            self.serial = temp
            return self.getSerial()
    def check(self):
        length = len(self.serial)
        halfLen = length / 2
        i = 0
        while i <= halfLen:
            if self.serial[i] == None:
                if self.serial[length - i - 1] == None:
                    i += 1
                else:
                    return False
            elif self.serial[length - i - 1] == None:
                return False
            elif self.serial[i].val == self.serial[length - i - 1].val:
                i += 1
            else:
                return False
        return True

理论上，这段代码是对的。然后提交后发现超时，观察了下超时的用例，树有非常多层，而且存在了很多的空节点。由于我的代码中，对于空节点也是在下一层时拆成两个空节点来看的，所以越往下层，节点会越多。改进点那就是把空节点去掉，但没有空节点占位的话，这就涉及如何判断节点是否镜像了，而且假如就是有很多层数据，而且不是空的话，算法本身的效率就是瓶颈了。

Code (参考coderliang)

# 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
        """
        if root == None:
            return True
        stack = [root.left, root.right]
        while not stack == None:
            if len(stack) == 0:
                return True
            left = stack.pop()
            right = stack.pop()
            if left == None and right == None:
                continue
            elif left == None or right == None:
                return False
            if not left.val == right.val:
                return False
            stack.append(left.left)
            stack.append(right.right)
            stack.append(left.right)
            stack.append(right.left)
        return True

清新多了，会看之前的代码，不忍直视…

Code (recursively 参考lvlolittle)

# 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 root == None or self.check(root.left, root.right)

    def check(self, left, right):
        if left == None or right == None:
            return left == right
        if left.val != right.val:
            return False
        return self.check(left.left, right.right) and self.check(left.right, right.left)

之前考虑怎么解决的时候还觉得递归没法实现，看到大神这样的代码，实在是惭愧。

Conclusion

题做的太少了，思维有些局限，没能灵活的运用代码解决问题。还是记住那句话好了，一题不能写超过50行代码，不然肯定是走弯路了。