Leetcode学习之路-day7：搜索与回溯算法

本系列博客记录学习图解算法数据结构（链接：力扣）

1.剑指 Offer 26. 树的子结构
输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)

B是A的子结构， 即 A中有出现和B相同的结构和节点值。

分为两步：

一是遍历A的所有节点

二是判断A每个节点是否与B结构相同。此题用双重递归：

# 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:
        def cur(A: TreeNode, B: TreeNode) -> bool:
            if not B: return True
            if not A: return False
            if A.val != B.val: return False
            return bool(cur(A.left,B.left) and cur(A.right,B.right))
        if not A or not B: return False 
        if cur(A,B): return True
        elif self.isSubStructure(A.left,B) or self.isSubStructure(A.right,B): return True
        else: return False

2.剑指 Offer 27. 二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

这道题比较简单，用一层递归即可：

# 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
        res = TreeNode(root.val)
        if root.left:
            res.right = self.mirrorTree(root.left)
        if root.right:
            res.left = self.mirrorTree(root.right)
        return res

3.剑指 Offer 28. 对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

显然此题也应该用递归的方式，即判断对称节点是否相同以及对称节点的左右节点是否对称相同：

# 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:
        if not root: return True
        def cur(L: TreeNode, R: TreeNode) -> bool:
            if not L and not R: return True
            if not L and R:return False
            if L and not R:return False
            if L.val != R.val: return False
            return cur(L.left,R.right) and cur(L.right,R.left)
        return cur(root.left, root.right)