leetcode5-31每日一题：对称二叉树

题目如下所示：

题目

观察了一下示例之后，我发现这里说的镜面对称就是从第二层开始，左子树的右子树和右子树的左子树的值是相等的，右子树的左子树和左子树的右子树的值是相等的，而且某一层的是相等的话，那就可以继续对它们的子树进行相同的操作。顺着这个思路的话，比较有效的办法就是使用递归了。思路有了，但是我的代码却写得并不太顺利，我觉得是我对于递归的使用并不熟悉导致的。
最开始的代码如下所示：

# 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:
        def judge_same(treenode1, treenode2):
            if (treenode1 == None and treenode2 != None) or (treenode1 != None and treenode2 == None):
                return False
            elif treenode1 != None and treenode2 != None:
                if treenode1.val != treenode2.val:
                    return False
                else:
                    judge_same(treenode1.left, treenode2.right)
                    judge_same(treenode2.left, treenode1.right)
        
        if root:
            if root.left.val == root.right.val:
                a = root.left
                b = root.right
                judge_same(a.left, b.right)
                judge_same(b.left, a.right)
            else:
                return False
        return True

这里先说明一下我个人认为的递归三要素：
①明确递归终止条件；
②提取重复逻辑，缩小递归规模；
③递归终止的返回值。

在上面这段代码中，我的思路是每次判断的时候，只考虑错误的情况，然后将False返回，True的情况则不返回，直接退出递归，到最后返回一个True。这段代码中犯的其中一个错误是没有给符合镜面的情况一个返回值，这样就会导致有情况会被遗漏。再者就是递归最外层的两个judge_same函数没有使用return来返回值，因为我天真地认为如果内部返回了False会导致最外层也让整个函数也返回False。还有一个错误就是递归的时候两个函数需要用and来返回他们的处理结果，因为镜面对称需要两种情况同时满足。（留下了不学无术的眼泪）
捣鼓了一下之后，方向还是有很多比较特殊的情况需要考虑，想了一下解决方法很麻烦，于是决定去评论区开开眼。然后看到有一个答案把输入的树作为判断函数的两个参数，也就是把输入的树分别作为左子树和右子树来看待，这样就可以避免很多的情况讨论传送门（先膜拜一下大佬）。于是乎我按照这个思路加上上面的反思，把自己的代码给改了一下，返回了一个正确的答案：

# 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:
        def judge_same(treenode1, treenode2):
            if not treenode1 and not treenode2:
                return True
            elif (treenode1 == None and treenode2 != None) or (treenode1 != None and treenode2 == None):
                return False
            elif treenode1 != None and treenode2 != None:
                if treenode1.val != treenode2.val:
                    return False
                else:
                    return judge_same(treenode1.left, treenode2.right) and judge_same(treenode2.left, treenode1.right)
        
        return judge_same(root, root)

除此之外还可以用迭代的方法做，我想了一下就是每次把树的每一层的数字提取出来，然后判断是不是回文数组，如果一直到最后都是，那就返回True，如果不是，则可以在检测到不是回文数组时就返回False结束判断。
迭代方法代码如下：

# 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:
        def judge(input_list):
            lens = len(input_list)
            for i in range(int(lens/2)):
                if input_list[i] != input_list[lens-1-i]:
                    return False
            return True
        
        if not root:
            return True
        else:
            lists = [root]
            while True:
                judges = []
                cache = []
                for i in range(len(lists)):
                    if lists[i].left == None:
                        judges.append(0.1997)
                    else:
                        judges.append(lists[i].left.val)
                        cache.append(lists[i].left)
                    if lists[i].right == None:
                        judges.append(0.1997)
                    else:
                        judges.append(lists[i].right.val)
                        cache.append(lists[i].right)
                if judge(judges):
                    if set(judges) == {0.1997}:
                        return True
                    else:
                        lists = cache
                else:
                    return False

虽然今天留下了不学无术的泪水，但是在把犯的错改正以后，收获也很大。希望现在多留下不学无术的泪水，以后就能笑嘻嘻