搜索与回溯算法——树的遍历（难）

太久没碰过树结构，不会深度遍历了。
输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)

参考答案：

通常不知道如何入手的题目，可能需要两个函数。

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

class Solution:
    def isSubStructure(self, A: TreeNode, B: TreeNode) -> bool:    
        if  not (A and B): return False # 这里A B必须不为空
        # python 没有|| &&
        return self.iscontain(A, B) or self.isSubStructure(A.left, B) or self.isSubStructure(A.right, B)

    # 以某个节点作为根节点匹配，使用 and。判断是否存在某个节点，使用 or。
    def iscontain(self, A: TreeNode, B: TreeNode): # 没有self不行
        if (B == None): # 检查完B就等于True，而不是B=A就返回True
            return True
        if (A == None or A.val != B.val):
            return False
        return self.iscontain(A.left, B.left) and self.iscontain(A.right, B.right) # 要使用self.函数

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

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root: return None # 不是return False
        # 先交换再往下遍历
        temp = root.left
        root.left = root.right
        root.right = temp
        self.mirrorTree(root.left)
        self.mirrorTree(root.right)
        return root
        # 先遍历到底在交换
        left = self.mirrorTree(root.left)
        right = self.mirrorTree(root.right)
        root.left, root.right = right, left
        return root

如果一棵二叉树和它的镜像一样，那么它是对称的。

考虑从顶至底递归，判断每对节点是否对称，从而判断树是否为对称二叉树。

判断条件：根节点要判断他的左右子节点即图中的2和2。而下一层的子节点（比较对象），并不是比较同一个父亲的兄弟节点，而是关于上一层两个兄弟节点的表兄弟节点。
该层符合对称二叉树的要求，开始比较下一层。

所以重点是：要比较的对象是谁？要比较的值是什么？
下图让人以为是要比较两层的节点，实际只需一层层地比较。

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        def judge(left, right):
            if not left and not right: return True
            if not left or not right or left.val != right.val: return False # 到这一步说明不同时为None
            # 而且先判断None 都不为None再判断节点的值
            return judge(left.left, right.right) and judge(left.right, right.left)

        if not root: return True
        return judge(root.left, root.right)