剑指Offer——面试题40：最小的k个数

面试题40：最小的k个数
题目：输入n个整数，找出其中最小的k个数。例如输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

解决思路

• 这道题最简单的思路莫过于把输入的n个整数排序，排序之后位于最前面的k个数就是最小的k个数。这种思路的时间复杂度是O(nlogn)。该方法不做介绍
• 解法一：时间复杂度为O(n)的算法，只有当我们可以修改输入的数组时可用

#include<iostream>
#include<algorithm>
using namespace std;
int RandomInRange(int min, int max){
    int random = rand() % (max - min + 1) + min;
    return random;
}
int Partition(int data[], int length, int start, int end){
    if(data == NULL || length <= 0 || start < 0 || end >= length)
        throw new std::exception();

    int index = RandomInRange(start, end);
    swap(data[index], data[end]);

    int small = start - 1;
    for(index = start; index < end; ++ index)
    {
        if(data[index] < data[end])
        {
            ++ small;
            if(small != index)
                swap(data[index], data[small]);
        }
    }

    ++ small;
    swap(data[small], data[end]);

    return small;
}
void GetLeastNumbers(int* input, int n, int* output,int k){
	if(input==NULL || output==NULL || k>n || n<=0 || k<=0) return ;
	int start=0, end=n-1;
	int index=Partition(input, n, start, end);
	while(index!=k-1){
		if(index>k-1) {
			end=index-1;
			index=Partition(input, n, start, end);
		}else{
			start=index+1;
			index=Partition(input, n, start, end);
		}
	}
	for(int i=0;i<k;i++) output[i]=input[i];
}

int main() {
	int numbers[]={4,5,1,6,2,7,3,8};
	int output[8];
	GetLeastNumbers(numbers, 8, output, 4);
	for(int i=0;i<4;i++){
		printf("%d\t", output[i]);
	}
	return 0;
}

采用这种思路是有限制的。我们需要修改输入的数组，因为函数Partition会调整数组中数字的顺序。如果面试官要求不能修改输入的数组，那么我们该怎么办呢？

• 解法二：时间复杂度为 O(nlongk) 的算法，特别适合处理海量数据

#include<iostream>
#include<algorithm>
#include<set>
#include<vector>
using namespace std;
typedef multiset<int, greater<int>> intSet;  // 默认排序大小"从小到大",利用greater进行修改 
typedef multiset<int, greater<int>>::iterator setIterator;
void GetLeastNumbers(const vector<int>& data, intSet& leastNumbers, int k){
	leastNumbers.clear();
	
	if(k<1 || data.size()<k) return ;
	
	vector<int>::const_iterator iter=data.begin();
	for(;iter!=data.end();iter++){
		if(leastNumbers.size()<k) leastNumbers.insert(*iter);
		else {
			setIterator iterGreatest=leastNumbers.begin();  // 该数为leastNumbers中的最大值 
			if(*iter<*(leastNumbers.begin())){
				leastNumbers.erase(iterGreatest);
				leastNumbers.insert(*iter);
			}
		}
	}
}

int main() {
	vector<int> data={4,5,1,6,2,7,3,8};
	intSet leastNumbers;
	GetLeastNumbers(data, leastNumbers, 4);
	for(setIterator it=leastNumbers.begin();it!=leastNumbers.end();it++){
		printf("%d\t", *it);
	}
	return 0;
}

两种解法的特点比较

	基于Partition函数的解法	基于堆或者红黑树的解法
时间复杂度	O(n)	O(nlogk)
是否需要修改输入数组	是	否
是否适用于海量数据	否	是