LeetCode-Interview40-最小的k个数
题目描述
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
我的题解
暴力排序
把数组升序排好，取出最前的k个即可,很暴力，比较低效, 仅适合与k接近与数组长度。
//java 8ms
public int[] getLeastNumbers(int[] arr, int k) {
Arrays.sort(arr);
int [] res = new int[k];
for (int i=0;i<k;i++){
res[i]=arr[i];
}
return res;
}
有限排序
想法是只找出k个最小数，不要对其他的数进行排序
//效率还是不行，比上面全排序还差，这个排序算法需要改进!
public int[] getLeastNumbers(int[] arr, int k) {
int len = arr.length;
int [] res = new int[k];
for (int i=0;i<k;i++){
int min = arr[i];
int minIndex=i;
for (int j=i+1;j<len;j++){
if (arr[j]<min){
min = arr[j];
minIndex=j;
}
}
if (minIndex!=i) arr[minIndex]=arr[i];
res[i]=min;
}
return res;
}
利用快速排序
快排：
private int [] quickSort(int []arr,int left,int right){//right=数组长-1
int L=left,R=right;
if (L<R){//至少2两个元素
int tmp = arr[L];//取基准
while (L<R){
//找出右边比基准小的第一个数，
while (L<R && arr[R]>=tmp)R--;
//找到了之后拿到左边：如果没有匹配的则L==R，相当于没替换
arr[L]=arr[R];
//找出左边比基准大的第一个元素
while (L<R && arr[L]<=tmp)L++;
//找到之后拿到右边
arr[R]=arr[L];
}
//跳出循环是L==R,arr[L]是中间的那个数，大小数居两边；
//注意上面：去掉内部while，发现执行了L=R’,R‘=L‘，即这个基准被改变了，需要还原：
arr[L] = tmp;
//那么左右递归，对子数组排序
quickSort(arr,left,L-1);
quickSort(arr,R+1,right);
}
return arr;
}
快排是选一个分解值，然后把小于的移到一边，大于的移到另一边，会返回分界值所在的下标。
这里每次找一个分界值，得出其下标m,m和K比较：
k=m：说明刚好找到
k<m:说明top k在前m个，递归(0,m-1)
k>m:说明还有m-k个数在(m+1,R)中，递归
public int[] getLeastNumbers(int[] arr, int k) {
if (k == 0) return new int[0];
else if(arr.length<=k)return arr;
topK(arr,0,arr.length-1,k);
int res [] = new int[k];
for (int i=0;i<k;i++)res[i]=arr[i];
return res;
}
private void topK(int []a,int left,int right,int k){
int m=partition(a,left,right);
if (m==k)return ;
else if (m>k)topK(a,left,m-1,k);
else topK(a,m+1,right,k);
}
//分区函数：
private int partition(int []a,int L,int R){
int tmp = a[L];
while (L!=R){
while (L<R && a[R]>=tmp)R--;
a[L]=a[R];
while(L<R && a[L]<=tmp)L++;
a[R]=a[L];
}
a[R]=tmp;
return R;
}
这里分区函数是将快排的递归为1的时候，这个赋值比较多，性能其实不太好
看到这个：
int partition_better(int[] a, int lo, int hi) {
int i = lo;
int j = hi + 1;
int v = a[lo];
while (true) {
while (a[++i] < v) //左到右扫描，找到第一个 >= v的
if (i == hi) break;//没有，退出
while (a[--j] > v)//右到左扫描，找到第一个 <= v的
if (j == lo)break;//没有，退出
if (i >= j) break;//扫描完毕，退出
swap(a, i, j);//找到后交换值
}
swap(a, lo, j);//j是分界下标，把分界值拿过去
return j;
}
void swap(int[] a, int i, int j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
其他题解
最大堆 O(NlogK)
// 保持堆的大小为K，然后遍历数组中的数字，遍历的时候做如下判断：
// 1. 若目前堆的大小小于K，将当前数字放入堆中。
// 2. 否则判断当前数字与大根堆堆顶元素的大小关系，如果当前数字比大根堆堆顶还大，这个数就直接跳过；
// 反之如果当前数字比大根堆堆顶小，先poll掉堆顶，再将该数字放入堆中。
class Solution {
public int[] getLeastNumbers(int[] arr, int k) {
if (k == 0 || arr.length == 0) {
return new int[0];
}
// 默认是小根堆，实现大根堆需要重写一下比较器。
Queue<Integer> pq = new PriorityQueue<>((v1, v2) -> v2 - v1);
for (int num: arr) {
if (pq.size() < k) {
pq.offer(num);
} else if (num < pq.peek()) {
pq.poll();
pq.offer(num);
}
}
// 返回堆中的元素
int[] res = new int[pq.size()];
int idx = 0;
for(int num: pq) {
res[idx++] = num;
}
return res;
}
}
二叉搜索树
class Solution {
public int[] getLeastNumbers(int[] arr, int k) {
if (k == 0 || arr.length == 0) {
return new int[0];
}
// TreeMap的key是数字, value是该数字的个数。
// cnt表示当前map总共存了多少个数字。
TreeMap<Integer, Integer> map = new TreeMap<>();
int cnt = 0;
for (int num: arr) {
// 1. 遍历数组，若当前map中的数字个数小于k，则map中当前数字对应个数+1
if (cnt < k) {
map.put(num, map.getOrDefault(num, 0) + 1);
cnt++;
continue;
}
// 2. 否则，取出map中最大的Key（即最大的数字), 判断当前数字与map中最大数字的大小关系：
// 若当前数字比map中最大的数字还大，就直接忽略；
// 若当前数字比map中最大的数字小，则将当前数字加入map中，并将map中的最大数字的个数-1。
Map.Entry<Integer, Integer> entry = map.lastEntry();
if (entry.getKey() > num) {
map.put(num, map.getOrDefault(num, 0) + 1);
if (entry.getValue() == 1) {
map.pollLastEntry();
} else {
map.put(entry.getKey(), entry.getValue() - 1);
}
}
}
// 最后返回map中的元素
int[] res = new int[k];
int idx = 0;
for (Map.Entry<Integer, Integer> entry: map.entrySet()) {
int freq = entry.getValue();
while (freq-- > 0) {
res[idx++] = entry.getKey();
}
}
return res;
}
}
计数排序
class Solution {
public int[] getLeastNumbers(int[] arr, int k) {
if (k == 0 || arr.length == 0) {
return new int[0];
}
// 统计每个数字出现的次数
int[] counter = new int[10001];
for (int num: arr) {
counter[num]++;
}
// 根据counter数组从头找出k个数作为返回结果
int[] res = new int[k];
int idx = 0;
for (int num = 0; num < counter.length; num++) {
while (counter[num]-- > 0 && idx < k) {
res[idx++] = num;
}
if (idx == k) {
break;
}
}
return res;
}
}
哈希
int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize){
int hash[10001] = {0};
int *ret;
int i,j;
if(k >= arrSize) {
*returnSize = arrSize;
return arr;
}
ret = malloc(sizeof(int) * k);
for(i = 0; i < arrSize; i++) {
hash[arr[i]]++;
}
i = 0; j = 0;
while(i < k) {
if(hash[j]) {
ret[i] = j;
hash[j]--;
i++;
} else {
j++;
}
}
*returnSize = k;
return ret;
}
桶计数
class Solution {
public:
vector<int> getLeastNumbers(vector<int>& arr, int k) {
vector<int> ret;
int m[10002];
memset(m, 0, sizeof(m));
for (auto i : arr) {
m[i] ++;
}
for (int i = 0; i < 10002; i ++) {
if (k <= 0) {
break;
}
int count = k < m[i] ? k : m[i];
while (count --) {
ret.push_back(i);
}
k -= m[i];
}
return ret;
}
};
