力扣树的进一步应用

654. 最大二叉树

解题思路：

1. 找到每一层最大的节点。
2. 有底向上逐层构建左右子树。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:

        if not nums: return

        n = nums.index(max(nums)) # 找出当前最大的节点

        left = self.constructMaximumBinaryTree(nums[:n]) # 利用分治， 递归构造左右子树
        right = self.constructMaximumBinaryTree(nums[n + 1:])

        root = TreeNode(nums[n], left, right) #后序遍历位置，从下至上逐层构建树
        return root

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

解题思路：

1. 前序遍历顺序的第一个节点为根节点。
2. 利用根节点在中序遍历顺序中的索引位置，划分前序与中序列表，逐层递归。

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

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:

        if not preorder or not inorder: return None
        
        root = TreeNode(preorder[0])
        # 因为没有重复元素，所以可以根据值来查找根节点在中序遍历中的位置
        midIndex = inorder.index(preorder[0])

        root.left = self.buildTree(preorder[1 :midIndex + 1], inorder[:midIndex])
        root.right = self.buildTree(preorder[midIndex + 1:], inorder[midIndex + 1:])

        return root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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

解题思路：

1. 后序遍历顺序的最后一个节点为根节点。
2. 利用根节点在中序遍历顺序中的索引位置，划分后序与中序列表，逐层递归。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:

        if not inorder or not postorder:
            return None

        root = TreeNode(postorder[-1])

        midIndex = inorder.index(postorder[-1])

        root.left = self.buildTree(inorder[:midIndex], postorder[:midIndex])
        root.right = self.buildTree(inorder[midIndex + 1:],	postorder[midIndex:-1])

        return root
        
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

889. 根据前序和后序遍历构造二叉树

解题思路：

1. 前序遍历顺序的第一个节点为根节点,后序遍历顺序的最后一个节点为根节点。
2. 采用前序遍历的方式，在前序遍历顺序中，第二个元素为左子树根节点的索引。
3. 利用左子树根节点在后序遍历中的位置，拆分前序和后序数组，递归构建子树。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def constructFromPrePost(self, preorder: List[int], postorder: List[int]) -> TreeNode:
        
        if not preorder or not postorder:
            return None


        root = TreeNode(preorder[0])

        # 因为不是寻找根节点，所以需要判断当前部分树的长度，如果pre的长度是1，直接返回root即可
        if len(preorder) == 1:
            return root
        
        midIndex = postorder.index(preorder[1]) # 第二个元素为左子树根节点的索引。

        root.left = self.constructFromPrePost(preorder[1:midIndex+2], postorder[:midIndex+1])
        root.right = self.constructFromPrePost(preorder[midIndex+2:], postorder[midIndex+1:-1])

        return root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25