取topK

从小到大取topK个数

方法一：快排的思想，当划分节点的前面刚好为k-1个，把到pivot的值返回就可以了。

class Solution:
    def __init__(self,arr):
        self.arr = arr
    def topK(self,k):
        n = len(self.arr)
        if k <=0 or k >=n:
            return []
        low = 0
        high = n-1
        mid = self.partition(low,high)
        while k-1 != mid:
            if k-1 > mid:
                low = mid+1
                mid = self.partition(low,high)
            elif k-1 < mid:
                high = mid - 1
                mid = self.partition(low,high)
        res = self.arr[:mid+1]
        print(res)

    def partition(self,low,high):
        pivotKey = self.arr[low]
        while low < high:
            while low < high and self.arr[high]>=pivotKey:
                high-=1
            self.arr[low],self.arr[high]=self.arr[high],self.arr[low]
            while low < high and self.arr[low]<=pivotKey:
                low+=1
            self.arr[low], self.arr[high] = self.arr[high], self.arr[low]
        return low

if __name__ == "__main__":
    Solution([4,3,6,7,2,8,0,1]).topK(6)

方法二：堆排序

一个很常见的例子，假设我们要选5个最矮的同学参加比赛，候选人选好之后又跑来一个新同学参加评选。这个时候新同学只需要PK候选人中最高的，如果他比最高的还高，就被淘汰，如果比最高的矮，他就可以替代这个最高的。按照这个思想，无论再来多少新同学都可以很快速的选择。

以这个思想为基础，为了最快的找到候选人中最高的，以身高为基准建立大顶堆，每次新人与堆顶PK，PK结束之后维护候选人重新为大顶堆。

这种思想将时间复杂度降到以k为基数，每次调整堆的时间复杂度都是，那么整体时间复杂度为。

class Solution2:
    def topK(self,nums,k):
        n = len(nums)
        if k <= 0 or k > n:
            return []
        # 建立大顶堆
        for i in range((k//2)-1, -1, -1):
            self.heapAjust(nums,i,k-1)
        for i in range(k,n):
            if nums[i]<nums[0]:
                nums[0],nums[i]=nums[i],nums[0]
                # 调整前k个数
                self.heapAjust(nums,0,k-1)
        print(nums[:k])
    def heapAjust(self,nums,start,end):
        temp = nums[start]
        # 记录较大的那个孩子下标
        child = 2 * start + 1
        while child <= end:
            # 比较左右孩子，记录较大的那个
            if child + 1 <= end and nums[child] < nums[child+1]:
                # 如果右孩子比较大，下标往右移
                child += 1
            # 如果根已经比左右孩子都大了，直接退出
            if temp >= nums[child]:
                break
            # 如果根小于某个孩子,将较大值提到根位置
            nums[start] = nums[child]
            # 接着比较被降下去是否符合要求，此时的根下标为原来被换上去的那个孩子下标
            start = child
            child = child * 2 + 1
        # 最后将一开始的根值放入合适的位置
        nums[start] = temp

原文链接：https://blog.csdn.net/qq_20141867/article/details/81152894