LeetCode打卡Task11-分治篇

一、知识点

了解归并排序递归的思想

二、例题

1.将有序数组转换为二叉搜索树

# 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 buildBST(self,nums,left,right):
        if left>right:
            return None
        mid=left+(right-left)//2
        root=TreeNode(nums[mid])
        root.left=self.buildBST(nums,left,mid-1)
        root.right=self.buildBST(nums,mid+1,right)
        return root
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        return self.buildBST(nums,0,len(nums)-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:
        self.map={j:i for i,j in enumerate(inorder)}
        self.postorder=postorder
        return self.f(0,len(postorder)-1)
    
    def f(self,l,r):
        if l>r:
            return None
        else:
            value=self.postorder.pop()
            index=self.map[value]
            right_node=self.f(index+1,r)
            left_node=self.f(l,index-1)
            return TreeNode(value,left_node,right_node)

3.多数元素

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        def f(l,r):
            if l==r:
                return nums[l]
            mid=(r+l)//2
            left_res=f(l,mid)
            right_res=f(mid+1,r)
            if left_res==right_res:
                return left_res
            else:
                count_left=sum(1 for i in range(l,r+1) if nums[i]==left_res)
                count_right=sum(1 for i in range(l,r+1) if nums[i]==right_res)
                return left_res if count_left>count_right else right_res
        return f(0,len(nums)-1)

4.最大子数组和

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        # opt=[nums[0]]
        # for i in nums[1:]:
        #     opt.append(max(opt[-1]+i,i))
        # return max(opt)
        if len(nums)==1:
            return nums[0]
        max_left=self.maxSubArray(nums[:len(nums)//2])
        max_right=self.maxSubArray(nums[len(nums)//2:])
        max_l = nums[len(nums)//2-1]
        tmp = 0
        for i in range(len(nums)//2-1,-1,-1):
            tmp += nums[i]
            max_l = max(tmp, max_l)
        max_r = nums[len(nums)//2]
        tmp = 0
        for i in range(len(nums)//2,len(nums)):
            tmp += nums[i]
            max_r = max(tmp, max_r)
        return max(max_right,max_left,max_l+max_r)

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

# 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:
        self.map={j:i for i,j in enumerate(inorder)}
        self.preorder=preorder
        return self.f(0,len(preorder)-1)
    
    def f(self,l,r):
        if l>r:
            return None
        else:
            value=self.preorder.pop(0)
            index=self.map[value]
            left_node=self.f(l,index-1)
            right_node=self.f(index+1,r)
            return TreeNode(value,left_node,right_node)