[leetcode] Python(28)--对称二叉树(101)、路径总和(112)、从中序与后序遍历序列构造二叉树(106)、从前序与中序遍历序列构造二叉树(105)

从零开始的力扣（第二十八天）~

1.对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。
—————————————————————————————————————————

迭代法操作，只是迭代时返回的是每次的最终结果，而不能依次迭代

# 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 BFS(node1, node2):
            if node1 is None and node2 is None:
                return True
            elif node1 and node2:
                if node1.val != node2.val:
                    return False
                if node1.left is None and node1.right is None and node2.left is None and node2.right is None:
                    return True
                return BFS(node1.left, node2.right) and BFS(node1.right, node2.left)
            else:
                return False
        return BFS(root, root)

2.路径总和

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例:
给定如下二叉树，以及目标和 sum = 22，

          5
         / \
        4   8
       /   / \
      11  13  4
     /  \      \
    7    2      1

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。
—————————————————————————————————————————

递归法，每次输入子树与此树要求的求和，而且必须在根节点判断sum=0

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

class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        def sumofNode(node, sum):
            if not node:
                return False
            sum -= node.val
            if not node.left and not node.right and sum == 0:
                return True
            return sumofNode(node.left, sum) or sumofNode(node.right, sum)
        return sumofNode(root, sum)

3.从中序与后序遍历序列构造二叉树

根据一棵树的中序遍历与后序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树：

—————————————————————————————————————————

迭代法完成，每次调用后序遍历最后一位在中序遍历中的位置，分成左右两子树进行递归

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

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        if len(inorder) < 1:
            return
        mid = inorder.index(postorder[-1])
        root = TreeNode(postorder[-1])
        leftNode = inorder[:mid]
        lenleft = len(leftNode)
        rightNode = inorder[mid + 1:]
        root.left = self.buildTree(leftNode, postorder[:lenleft])
        root.right = self.buildTree(rightNode, postorder[lenleft:-1])
        return root

4.从前序与中序遍历序列构造二叉树

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：
—————————————————————————————————————————

与上题方法相同

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

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if len(preorder) < 1:
            return
        mid = inorder.index(preorder[0])
        root = TreeNode(preorder[0])
        leftNode = inorder[:mid]
        lenleft = len(leftNode)
        rightNode = inorder[mid + 1:]
        root.left = self.buildTree(preorder[1:lenleft + 1], leftNode)
        root.right = self.buildTree(preorder[lenleft + 1:], rightNode)
        return root