剑指offer实践 ——40.最小的k个数（python版)

---

题目

最小的k个数

---

一、思路 排序

对输入的数组做排序，然后找出排序后的前4个数。
贴一下各个排序算法的时间复杂度：

本例使用快速排序来实现最小的k个数，其他排序见大神的总结：
https://www.cnblogs.com/Mufasa/p/10527387.html

def partition(arr, low, high):
    i = (low - 1)  # 最小元素索引
    pivot = arr[high]

    for j in range(low, high):

        # 当前元素小于或等于 pivot
        if arr[j] <= pivot:
            i = i + 1
            arr[i], arr[j] = arr[j], arr[i]

    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return (i + 1)

# 快速排序函数
def quickSort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)

        quickSort(arr, low, pi - 1)
        quickSort(arr, pi + 1, high)

最小的k个数：

def min_k_num_1(arr):
    if not arr:
        return []

    quickSort(arr, 0, len(arr)-1)
    return arr[:4]

二、思路 利用容器

利用一个大小为k的容器来存放最小的k个数。
这个容器可以为最大堆，也可以为红黑树。
何为红黑树？
https://www.cnblogs.com/zjutzz/p/3281319.html
何为最大堆？
https://blog.csdn.net/jamfiy/article/details/88185512

这种方法采用了python自带的headpq小顶堆
时间复杂度：O(n\log k)O(nlogk)：
        其中 nn 是数组 arr 的长度。
        由于大根堆实时维护前 kk 小值，所以插入删除都是 O(\log k)O(logk) 的时间复杂度，最坏情况下数组里 nn 个数都会插入，所以一共需要 O(n\log k)O(nlogk) 的时间复杂度
空间复杂度：O(k)O(k)，因为大根堆里最多 kk 个数

def min_k_num_2(arr, k):
    if not arr or k > len(arr) or k <= 0:
        return []
    # 将前k个数放入堆中
    h = [-x for x in arr[:k]]
    heapq.heapify(h)
    for i in range(k, len(arr)):
        if -h[0] > arr[i]:
            heapq.heappop(h)
            heapq.heappush(h, -arr[i])
    res = [-x for x in h]
    return res