[每日一题]73：最小的K个数

---

题目描述

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

示例 1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

示例 2：

输入：arr = [0,1,2,1], k = 1
输出：[0]

题解思路

方法一：排序

对原数组从小到大排序后取出前 k 个数即可。

复杂度分析：

• 时间复杂度：$O(nlogn)$，其中 n 是数组 arr 的长度。算法的时间复杂度即排序的时间复杂度。
• 空间复杂度：$O(logn)$，排序所需额外的空间复杂度为 $O(logn)$。空间占用是递归造成的栈空间的使用

代码实现：

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> res;
        sort(arr.begin(), arr.end());
        for(int i = 0; i < k; ++i){
            res.push_back(arr[i]);
        }
        return res;
    }
};

方法二：快排最最最高效解决 TopK 问题：O(N)

注意找前 K 大/前 K 小问题不需要对整个数组进行 O(NlogN) 的排序！
例如本题，直接通过快排切分排好第 K 小的数（下标为 K-1），那么它左边的数就是比它小的另外 K-1 个数啦～

代码实现：

class Solution {
public:
    void QuickSort(vector<int>& v, int left, int right, int k){
        if(left > right) return;
        int i = left, j = right, tmp = v[left];
        while(i < j){
            while(v[j] >= tmp && i < j) j--;
            while(v[i] <= tmp && i < j) i++;
            if(i < j) swap(v[i], v[j]);
        }
        v[left] = v[i];
        v[i] = tmp;

        if(i == k-1) return;
        else if(i < k-1) return QuickSort(v, i+1, right, k);
        else return QuickSort(v, left, i-1, k);
    }

    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        QuickSort(arr, 0, arr.size()-1, k);
        vector<int> res;
        for(int i = 0; i < k; i++) res.push_back(arr[i]);
        return res;
    }
};

方法三：堆（最经典的解法）

我们用一个大根堆实时维护数组的前 k 小值。首先将前 k 个数插入大根堆中，随后从第 k+1 个数开始遍历，如果当前遍历到的数比大根堆的堆顶的数要小，就把堆顶的数弹出，再插入当前遍历到的数。最后将大根堆里的数存入数组返回即可。 C++ 语言中的堆（即优先队列）为大根堆，我们可以这么做。

复杂度分析：

• 时间复杂度：O(nlogk)，其中 n 是数组 arr 的长度。由于大根堆实时维护前 k 小值，所以插入删除都是 O(logk) 的时间复杂度，最坏情况下数组里 n 个数都会插入，所以一共需要 O(nlogk) 的时间复杂度。
• 空间复杂度：O(k)，因为大根堆里最多 k 个数。

代码实现：

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> vec;
        if (k == 0) return vec; // 排除 0 的情况
        
        priority_queue<int> Q;
        for (int i = 0; i < k; ++i) {
            Q.push(arr[i]);
        }
        for (int i = k; i < arr.size(); ++i) {
            if (Q.top() > arr[i]) {
                Q.pop();
                Q.push(arr[i]);
            }
        }
        for (int i = 0; i < k; ++i) {
            vec.push_back(Q.top());
            Q.pop();
        }
        return vec;
    }
};

---

C代码示例：

#include <iostream>
#include <vector>
using namespace std;

class Solution {
	void HeapAdjustDown(vector<int>& arr, int start, int end) {
		int temp = arr[start];
		int i = start * 2 + 1;
		while (i <= end) {
			if (i + 1 <= end && arr[i + 1] < arr[i]) {
				i++;
			}
			if (arr[i] > temp) {
				break;
			}
			arr[start] = arr[i];
			start = i;
			i = start * 2 + 1;
		}
		arr[start] = temp;
	}
public:
	vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
		vector<int> result;
		if (input.size() == 0 || k == 0 || k > input.size()) {
			return result;
		}

		int len = input.size();
		// 初始化堆
		for (int i = len / 2 - 1; i >= 0; i--) {
			HeapAdjustDown(input, i, len - 1);
		}
		for (; k > 0; k--) {
			result.push_back(input[0]);
			int temp = input[len - 1];
			input[len - 1] = input[0];
			input[0] = temp;

			len--;
			//将arr[0...i-1]重新调整为最大堆
			HeapAdjustDown(input, 0, len - 1);
		}
		return result;
	}
};

int main() {
	Solution s;
	int n, k;
	cin >> n >> k;
	vector<int> v, re;
	v.resize(n);
	for (int i = 0; i < n; i++) {
		cin >> v[i];
	}
	re = s.GetLeastNumbers_Solution(v, k);
	for (int i = 0; i < re.size(); i++) {
		cout << re[i] << ',';
	}
	return 0;
}

代码生成图：

---

如有不同见解，欢迎留言讨论～～