Leetcode-day3 [215] O K-ésimo maior elemento do array

215. O K-ésimo maior elemento em uma matriz

tema

Dada uma matriz de inteiros numse inteiros k, retorne ko .

Observe que você está procurando o k-ésimo maior elemento da matriz classificada, não o k-ésimo elemento distinto.

Você deve projetar e implementar um algoritmo O(n)de para resolver este problema.

ideias para resolução de problemas

Depois de ler a pergunta, não é difícil ver que ela exige que classifiquemos primeiro o array original. E a complexidade de tempo do algoritmo de classificação precisa ser $O\left(n\right)$ . (A complexidade do primeiro tempo é$O\left(n^2\right)$O algoritmo de classificação por inserção falha porque o limite de tempo foi excedido. ) Em seguida, com a mentalidade de tentar, chame asortedfunção interna do Python para resolvê-lo diretamente.

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        return sorted(nums)[-k]

Ideias para resolução de problemas 【Aprendizagem】

Obviamente, o objetivo dessa questão do algoritmo definitivamente não é aprender como ajustar a API para resolver o problema. Depois de examinar a solução, descobri que a classificação rápida ou a classificação de heap é necessária para atender aos requisitos de complexidade de tempo do problema.

A complexidade de tempo e espaço de vários algoritmos de classificação são as seguintes: Complexidade de tempo e espaço de vários algoritmos de classificação_Complexidade de tempo do algoritmo de classificação_Fang tongxue's blog-CSDN blog

Método de seleção baseado em classificação rápida

Referência ao texto original: "TopK Problem" Quick Sort e Heap Sort Explicação Detalhada - O Kth Maior Elemento no Array - LeetCode

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        import random

        def partition(nums, left, right):
            pivot = nums[left]  # 选择一个基准值（最左端元素）
            i, j = left, right  # 双指针
            while i < j:
                while i < j and nums[j] >= pivot:  # 从右往左查找，直到找到一个比pivot更小的数
                    j -= 1
                nums[i] = nums[j]  # 将更小的数放入左边
                while i < j and nums[i] <= pivot:  # 从左往右查找，直到找到一个比pivot更大的数
                    i += 1
                nums[j] = nums[i]  # 将更大的数放入右边
            # 循环结束，i与j相等
            nums[i] = pivot  # 待比较数据放入最终位置
            return i  # 返回基准值最终位置

        def randomPartition(nums, left, right):
            pivot_idx = random.randint(left, right)  # 随机选择pivot
            nums[left], nums[pivot_idx] = nums[pivot_idx], nums[left]  # pivot放置到最左边
            return partition(nums, left, right)  # 调用partition函数

        def topk_split(nums, k, left, right):
            # 寻找到第k个数停止递归，使得nums数组中index左边是前k个小的数，index右边是后面n-k个大的数
            if left < right:
                index = randomPartition(nums, left, right)
                # index = partition(nums, left, right)
                if index == k:
                    return
                elif index < k:
                    topk_split(nums, k, index + 1, right)
                else:
                    topk_split(nums, k, left, index - 1)
        
        # 获得第k大的数
        def topk_large(nums, k):
            # parttion是按从小到大划分的，如果让index左边为前n-k个小的数，则index右边为前k个大的数
            topk_split(nums, len(nums) - k, 0, len(nums) - 1)  # 把k换成len(nums)-k
            return nums[len(nums) - k]

        return topk_large(nums,k)