首页 > 编程语言 >[Python手撕]TOPK

[Python手撕]TOPK

时间:2024-08-31 11:37:01浏览次数:8  
标签:arr return Python partition mid len TOPK 排序

TOP K

问题描述:

从arr[1, n]这n个数中,找出最大的k个数,这就是经典的TopK问题。

栗子:

从arr[1, 12]={5,3,7,1,8,2,9,4,7,2,6,6} 这n=12个数中,找出最大的k=5个。

整体排序

排序是最容易想到的方法,将n个数排序之后,取出最大的k个,即为所得。

伪代码:

sort(arr, 1, n);
return arr[1, k];

时间复杂度:O(n*lg(n))

分析:明明只需要TopK,却将全局都排序了,这也是这个方法复杂度非常高的原因。那能不能不全局排序,而只局部排序呢?这就引出了第二个优化方法。

局部排序

不再全局排序,只对最大的k个排序。
冒泡是一个很常见的排序方法,每冒一个泡,找出最大值,冒k个泡,就得到TopK。

伪代码:

for(i=1 to k){
    bubble_find_max(arr,i);
}
return arr[1, k];

时间复杂度:O(n*k)

分析:冒泡,将全局排序优化为了局部排序,非TopK的元素是不需要排序的,节省了计算资源。不少朋友会想到,需求是TopK,是不是这最大的k个元素也不需要排序呢?这就引出了第三个优化方法。

思路:只找到TopK,不排序TopK。
先用前k个元素生成一个小顶堆,这个小顶堆用于存储,当前最大的k个元素。
接着,从第k+1个元素开始扫描,和堆顶(堆中最小的元素)比较,如果被扫描的元素大于堆顶,则替换堆顶的元素,并调整堆,以保证堆内的k个元素,总是当前最大的k个元素。
直到,扫描完所有n-k个元素,最终堆中的k个元素,就是求的TopK。

import heapq

nums = [1, 4, 7, 8, 5, 2, 3, 6, 9]
k = 3

heap = nums[:k]
heapq.heapify(heap)

for i in nums[k:]:
    if i > heap[0]:
        heapq.heappop(heap)
        heapq.heappush(heap, i)

print(heap)

时间复杂度:O(n*lg(k))

画外音:n个元素扫一遍,假设运气很差,每次都入堆调整,调整时间复杂度为堆的高度,即lg(k),故整体时间复杂度是n*lg(k)。

分析:堆,将冒泡的TopK排序优化为了TopK不排序,节省了计算资源。堆,是求TopK的经典算法,那还有没有更快的方案呢?

随机选择

随机选择算在是《算法导论》中一个经典的算法,其时间复杂度为O(n),是一个线性复杂度的方法。
这个方法并不是所有同学都知道,为了将算法讲透,先聊一些前序知识,一个所有程序员都应该烂熟于胸的经典算法:快速排序。

其伪代码是:

void quick_sort(int[]arr, int low, int high){
         if(low==high) return;
         int i = partition(arr, low, high);
         quick_sort(arr, low, i-1);
         quick_sort(arr, i+1, high);
}

其核心算法思想是,分治法。

分治法(Divide&Conquer),把一个大的问题,转化为若干个子问题(Divide),每个子问题“都”解决,大的问题便随之解决(Conquer)。这里的关键词是“都”。从伪代码里可以看到,快速排序递归时,先通过partition把数组分隔为两个部分,两个部分“都”要再次递归。
分治法有一个特例,叫减治法。

减治法(Reduce&Conquer),把一个大的问题,转化为若干个子问题(Reduce),这些子问题中“只”解决一个,大的问题便随之解决(Conquer)。这里的关键词是“只”。

二分查找binary_search,BS,是一个典型的运用减治法思想的算法,其伪代码是:

int BS(int[]arr, int low, inthigh, int target){
         if(low> high) return -1;
         mid= (low+high)/2;
         if(arr[mid]== target) return mid;
         if(arr[mid]> target)
                   return BS(arr, low, mid-1, target);
         else
                   return BS(arr, mid+1, high, target);

}

从伪代码可以看到,二分查找,一个大的问题,可以用一个mid元素,分成左半区,右半区两个子问题。而左右两个子问题,只需要解决其中一个,递归一次,就能够解决二分查找全局的问题。

通过分治法与减治法的描述,可以发现,分治法的复杂度一般来说是大于减治法的:
快速排序:O(n*lg(n))
二分查找:O(lg(n))

话题收回来,快速排序的核心是:
i = partition(arr, low, high);
这个partition是干嘛的呢?
顾名思义,partition会把整体分为两个部分。
更具体的,会用数组arr中的一个元素(默认是第一个元素t=arr[low])为划分依据,将数据arr[low, high]划分成左右两个子数组:
左半部分,都比t大
右半部分,都比t小
中间位置i是划分元素

以上述TopK的数组为例,先用第一个元素t=arr[low]为划分依据,扫描一遍数组,把数组分成了两个半区:
左半区比t大
右半区比t小
中间是t
partition返回的是t最终的位置i。

很容易知道,partition的时间复杂度是O(n)。

画外音:把整个数组扫一遍,比t大的放左边,比t小的放右边,最后t放在中间N[i]。

partition和TopK问题有什么关系呢?

TopK是希望求出arr[1,n]中最大的k个数,那如果找到了第k大的数,做一次partition,不就一次性找到最大的k个数了么?

画外音:即partition后左半区的k个数。

问题变成了arr[1, n]中找到第k大的数。

再回过头来看看第一次partition,划分之后:

i = partition(arr, 1, n);

如果i大于k,则说明arr[i]左边的元素都大于k,于是只递归arr[1, i-1]里第k大的元素即可;

如果i小于k,则说明说明第k大的元素在arr[i]的右边,于是只递归arr[i+1, n]里第k-i大的元素即可;

这就是随机选择算法randomized_select,RS,其伪代码如下:

int RS(arr, low, high, k){
  if(low== high) return arr[low];
  i= partition(arr, low, high);
  temp= i-low; //数组前半部分元素个数
  if(temp>=k)
      return RS(arr, low, i-1, k); //求前半部分第k大
  else
      return RS(arr, i+1, high, k-i); //求后半部分第k-i大
}

现在来看TOPK例题

Leetcode 面试题 17.14. 最小K个数

设计一个算法,找出数组中最小的k个数。以任意顺序返回这k个数均可。

给出python实现

class Solution:
    def smallestK(self, arr: List[int], k: int) -> List[int]:

        def top(arr,k):
            left,mid,right = partition(arr)
            left_length = len(left)
            mid_length = len(mid)

            if left_length >= k:
                return top(left,k)
            elif k>left_length and k<= left_length+mid_length:
                return left + mid[:k-left_length]
            elif k>left_length + mid_length:
                return left+mid+top(right,k-left_length-mid_length)

        def partition(arr):
            if not arr:
                return [],[],[]
            select = random.choice(arr)
            left,mid,right = [],[],[]
            for value in arr:
                if value < select:
                    left.append(value)
                elif value == select:
                    mid.append(value)
                elif value > select:
                    right.append(value)
            return left,mid,right

        if k == 0:
            return []
        return top(arr,k)

现在来看第K个数

Leetcode LCR 076. 数组中的第 K 个最大元素

给定整数数组 nums 和整数 k,请返回数组中第 k 个最大的元素。
请注意,你需要找的是数组排序后的第 k 个最大的元素,而不是第 k 个不同的元素。

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

        def topK(nums, k):
            left, mid, right = partition(nums)
            left_length = len(left)
            mid_length = len(mid)
            right_length = len(right)

            if right_length >= k:
                return topK(right, k)
            elif k > right_length and k <= right_length + mid_length:
                return mid[0]
            elif k > right_length + mid_length:
                return topK(left, k - right_length - mid_length)

        def partition(arr):
            if not arr:
                return [], [], []
            select = random.choice(arr)
            left,mid,right = [],[],[]
            for n in arr:
                if n < select:
                    left.append(n)
                elif n == select:
                    mid.append(n)
                elif n > select:
                    right.append(n)
            return left, mid, right

        return topK(nums,k)



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

        def partition(nums):

            pivot =random.choice(nums)

            less = []
            equals = []
            bigger = []

            for i in nums:
                if i < pivot:
                    less.append(i)
                if i == pivot:
                    equals.append(i)
                if i>pivot:
                    bigger.append(i)
            
            return less,equals,bigger

        def find(nums,k):
            less,equal,bigger = partition(nums)

            less_len = len(less)
            equal_len = len(equal)
            bigger_len = len(bigger)

            if bigger_len >= k:
                return find(bigger,k)
            if (bigger_len+equal_len) >= k and bigger_len < k:
                return equal[0]
            if (bigger_len+equal_len) < k:
                return find(less,k-bigger_len-equal_len)

        return find(nums,k)


再次强调一下:
分治法,大问题分解为小问题,小问题都要递归各个分支,例如:快速排序
减治法,大问题分解为小问题,小问题只要递归一个分支,例如:二分查找,随机选择
通过随机选择(randomized_select),找到arr[1, n]中第k大的数,再进行一次partition,就能得到TopK的结果。

总结

  • TopK,不难;其思路优化过程,不简单

  • 全局排序,O(n*lg(n))

  • 局部排序,只排序TopK个数,O(n*k)

  • 堆,TopK个数也不排序了,O(n*lg(k))

  • 分治法,每个分支“都要”递归,例如:快速排序,O(n*lg(n))

  • 减治法,“只要”递归一个分支,例如:二分查找O(lg(n)),随机选择O(n)

  • TopK的另一个解法:随机选择+partition

标签:arr,return,Python,partition,mid,len,TOPK,排序
From: https://www.cnblogs.com/DCFV/p/18390042

相关文章

  • 豆包 API 调用示例代码详解-Python版
    文章目录豆包API调用示例代码详解-Python版一、事前准备二、所需Python包三、代码详解五、源码下载四、总结豆包官方API文档豆包API调用示例代码详解-Python版在本文中,我们将详细介绍如何使用Python调用豆包API,并提供相关的事前准备和代码执行步骤。一、......
  • 使用 Python 实现自动化办公
    使用Python实现自动化办公在现代办公环境中,自动化是提高工作效率和减少人为错误的重要手段之一。Python是一种功能强大且灵活的编程语言,可以轻松地实现自动化办公任务。下面是一个简单的示例,展示如何使用Python实现自动化办公:需求:假设我们有一个Excel文件,名为"报表.xls......
  • [Python办公]一文入门图论Graphs,轻松处理最短路径等问题!
            [Python办公]一文入门图论Graphs,轻松处理最短路径等问题!        图论是研究图这种数学结构的性质和应用的学科。图(Graphs)由节点(或顶点)和连接这些节点的边组成,它是一种强大的数据结构,广泛应用于各种领域。以下举例用最短距离来入门图论。入门问题: ......
  • Python数据清洗基础
    在Python中进行数据清洗和可视化是一个多步骤的过程,涉及到数据的读取、预处理、分析和图形表示。以下是一些关键步骤和代码示例,这些步骤可以帮助你从原始数据中提取有价值的信息,并以直观的方式展示。数据清洗读取数据:importpandasaspddata=pd.read_csv('data.csv')处......
  • [Python知识点]list列表append()和extend()的区别
    在Python中,list.append()和list.extend()都是列表(list)的方法,用于添加元素,但它们的工作方式有所不同:list.append(x):这个方法将对象x添加到列表的末尾。x可以是任何数据类型,包括列表。如果x是一个列表,那么这个列表会被作为一个单个元素添加到原列表的末尾。list.extend(itera......
  • 6种有效的时间序列数据特征工程技术(使用Python)
    在商业分析中,"时间"是一个核心概念。我们基于时间组件来分析销售数据、收入、利润、增长,甚至进行预测。然而,对于初学者来说,这可能是一个复杂的主题。在处理时间敏感的数据集时,需要考虑时间序列数据的多个细微方面。在这个领域,没有放之四海而皆准的方法。我们不必总是强制使用传......
  • python学习总结--面向对象
    1.面向对象(上)1.1定义面向对象编程:oop[objectorientedprogramming]是一种python的编程思路;面向过程:就是我们一开始学习的,按照解决问题的步骤去写代码【根据业务逻辑去写代码】,在思考问题的时候,首先分析'怎么按照步骤去实现'然后将问题解决拆解成若干个步骤,并将这些步骤对......
  • 【python】PyQt5中富文本框QTextEdit的详细教程与应用实战
    ✨✨欢迎大家来到景天科技苑✨✨......
  • python 绘制双y轴,将折线加粗并在折线上做标记
    之前的笔记折线实在是太细了,并且还有点透明,放在论文中特别难看,现在修改一下折线,并且绘制双y轴 #!usr/bin/envpython#-*-coding:utf-8_*-"""@author:Suyue@file:jakjdklj.py@time:2024/08/30{DAY}@desc:"""importpandasaspdimportmatplotlibimportmatplo......
  • 探索Python中的拼音魔法:pypinyin库的奇妙之旅
    文章目录探索Python中的拼音魔法:pypinyin库的奇妙之旅背景:为何选择pypinyin?库简介:pypinyin是什么?安装指南:如何将pypinyin纳入你的项目?功能探索:pypinyin的五大核心函数实战演练:pypinyin在不同场景下的应用常见问题:使用pypinyin时的三个常见bug及解决方案总结:pypinyin-你......