題目描寫敘述：

輸入n個整數。找出當中最小的K個數。比如輸入4,5,1,6,2,7,3,8這8個數字，則最小的4個數字是1,2,3,4,。

輸入：

每一個測試案例包含2行：

第一行為2個整數n，k(1<=n。k<=200000)。表示數組的長度。

第二行包括n個整數。表示這n個數，數組中的數的範圍是[0,1000 000 000]。

輸出：

相應每一個測試案例，輸出最小的k個數。並按從小到大順序打印。

例子輸入：

8 44 5 1 6 2 7 3 8

例子輸出：

1 2 3 4

思路1：使用高速排序（或者其它排序）對這n個數進行排序。取出前k個就可以（O(nlogn)）。 思路2：我們能夠使用快排的partition操作來解決這個問題。假設基於數組的第k個數字進行調整。使得比第k個數字小的全部數字出如今其左邊。而比該數字大的出如今右邊，這樣，位於數組中左邊的k個數字即為所求。

（O（n））

方案2代碼：

/*
最小的k個數
by Rowandjj
2014/8/9
*/
#include<stdio.h>
#include<stdlib.h>
int partition(int arr[],int low,int high)
{
	int val = arr[low];
	while(low < high)
	{
		while(low < high && arr[high] >= val)
		{
			high--;
		}
		arr[low] = arr[high];
		while(low < high && arr[low] <= val)
		{
			low++;
		}
		arr[high] = arr[low];
	}
	arr[low] = val;
	return low;
}
//獲取最小的k個數
void GetLeastNumbers(int input[],int n,int output[],int k)
{
	if(input == NULL || output == NULL || n<=0 || k<=0 || k > n)
	{
		return;
	}
	int low = 0,high = n-1;
	int index = partition(input,low,high);
	while(index != k-1)
	{
		if(index > k-1)
		{
			high = index - 1;
			index = partition(input,low,high);
		}else
		{
			low = index+1;
			index = partition(input,low,high);
		}
	}
	for(int i = 0; i < k; i++)
	{
		output[i] = input[i];
	}
}
//-------------------------
//這題要求最小的k個數保持有序，故而使用快排對其進行排序
void QuickSort(int arr[],int low,int high)
{
	if(arr == NULL || low >= high)
	{
		return;
	}
	int index = partition(arr,low,high);
	QuickSort(arr,low,index-1);
	QuickSort(arr,index+1,high);
}
int main()
{
	int n,k;
	int output[200000];
	while(scanf("%d %d",&n,&k) != EOF)
	{
		if(n <= 0 || k <= 0 || k > n)
		{
			continue;
		}
		int *arr = (int*)malloc(sizeof(int)*n);
		if(!arr)
		{
			exit(-1);
		}
		for(int i = 0; i < n; i++)
		{
			scanf("%d",arr+i);
		}
		GetLeastNumbers(arr,n,output,k);
		QuickSort(output,0,k-1);
		for(int j = 0; j < k; j++)
		{
			if(j == k-1)
			{
				printf("%d\n",output[j]);
			}else
			{
				printf("%d ",output[j]);
			}
			
		}
                free(arr);
	}
	return 0;
}

[適合處理海量數據]思路3：能夠先創建一個大小為k的數據容器來存儲最小的k個數字，接下來我們每次從輸入的n個整數中讀入一個數，假設容器中已有的數字少於k個，則直接把這次讀入的整數放到容器中，假設容器中已有k個數字，此時我們不再插入新的數字。而僅僅能替換已有的數字。

找出這已有的k個數中的最大值，然後拿這次待插入的整數和最大值進行比較，假設待插入的值比當前已有的最大值小，則用這個數替換當前已有的最大值，假設待插入的值比當前已有的最大值還要大，那麽拋棄這個數。

容器能夠使用大頂堆來實現。

大頂堆的根始終最大。我們僅僅需將待插入的整數和堆頂進行比較就可以，假設發生替換，則僅僅需調整大頂堆堆頂元素（能夠使用堆排序中用到的那個HeapAdjust函數）。

代碼：

/*
最小的k個數
by Rowandjj
2014/8/10
*/
#include<stdio.h>
#include<stdlib.h>
void HeapAdjust(int arr[],int start,int end)
{
	if(arr == NULL || start < 0 || end <= 0 || start >= end)
	{
		return;
	}
	int temp = arr[start];
	int i = start*2+1;
	while(i <= end)
	{
		if(i+1<=end && arr[i+1]>arr[i])
		{
			i++;
		}
		if(temp > arr[i])
		{
			break;
		}
		arr[start] = arr[i];
		start = i;
		i = i*2+1;
	}
	arr[start] = temp;
}
bool GetLeastNumbers(int input[],int n,int output[],int k)
{
	if(input == NULL || output == NULL || n <= 0 || k <= 0 || k > n)
	{
		return false;
	}
	int count = 0;
	bool needBuildHeap = true;
	for(int i = 0; i < n; i++)
	{
		if(count < k)
		{
			output[count++] = input[i];
		}else
		{		
			//第一次須要總體建堆
			if(needBuildHeap)
			{
				for(int j = k/2-1;j >= 0; j--)//建堆,從第一個非葉子結點開始
				{
					HeapAdjust(output,j,k-1);
				}
				needBuildHeap = false;
			}
			//大頂堆建好之後，比較當前遍歷的整數與堆頂元素大小
			if(input[i] >= output[0])//大於等於堆頂元素
			{
				continue;//舍棄
			}
			//假設比堆頂元素小，那麽須要交換
			output[0] = input[i];
			HeapAdjust(output,0,k-1);//又一次調整為大頂堆
		}				
	}
	return true;
}
//------------------------------------------
//由於要求從小到大排序，故而這裏來一個堆排序
void HeapSort(int arr[],int len)
{
	if(arr == NULL || len <= 1)
	{
		return;
	}
	int i;
	for(i = len/2-1; i >= 0; i--)
	{
		HeapAdjust(arr,i,len-1);
	}
	for(i = len-1; i > 0; i--)
	{
		int temp = arr[0];
		arr[0] = arr[i];
		arr[i] = temp;
		HeapAdjust(arr,0,i-1);
	}
}
int main()
{
	int n,k;
	while(scanf("%d %d",&n,&k) != EOF)
	{
		if(n <= 0 || k <= 0)
		{
			continue;
		}
		int output[200000];
		int *arr = (int*)malloc(sizeof(int)*n);
		if(!arr)
		{
			exit(-1);
		}
		int i;
		for(i = 0; i < n; i++)
		{	
			scanf("%d",arr+i);
		}
		GetLeastNumbers(arr,n,output,k);
		HeapSort(output,k);
		for(i = 0; i < k; i++)
		{
			if(i == k-1)
			{
				printf("%d\n",output[i]);
			}else
			{
				printf("%d ",output[i]);
			}
			
		}
		free(arr);
	}
	return 0;
}

最小的k個數