面试题25：最小的K个数

方法一：对n个整数进行排序(快速排序或堆排序)，取出前K个元素(最容易想到的最笨的方法，不可取)

时间复杂度：O(n*logn) + O(k) = O(n*logn)

采用快速排序的代码：

#include "stdafx.h"
#include <iostream>
using namespace std;

//划分数组，找到枢轴元素下标，使得其左边的元素都比其小，右边的元素都比其大
int Partition(int nArr[], int nLength)
{
	//初始状态下，选取数组的第一个元素作为枢轴元素
	int nPivot = nArr[0];

	//设置两个游标
	int nLow = 0;
	int nHigh = nLength - 1;

	while (nLow < nHigh)
	{
		while (nLow < nHigh && nArr[nHigh] >= nPivot)
		{
			nHigh--;
		}
		nArr[nLow] = nArr[nHigh];

		while (nLow < nHigh && nArr[nLow] <= nPivot)
		{
			nLow++;
		}
		nArr[nHigh] = nArr[nLow];
	}

	nArr[nLow] = nPivot;
	return nLow;
}

void FastSort(int nArr[], int nLength)
{
	if (nArr == NULL || nLength <= 0)
	{
		return;
	}

	int nMidIndex = Partition(nArr, nLength);
	FastSort(nArr, nMidIndex);
	FastSort(nArr + nMidIndex + 1, nLength - 1 - nMidIndex);
}

int _tmain(int argc, _TCHAR* argv[])
{
	int nArr1[8] = {4, 5, 1, 6, 2, 7, 3, 8};
	int nArr2[8] = {4, 5, 2, 6, 2, 5, 3, 5};
	int nArr3[8] = {1, 1, 1, 1, 1, 1, 1, 1};

	while (1)
	{
		int k = 0;
		cout << "请输入最小数的个数：";
		cin >> k;
		if (k == 0)
		{
			break;
		}

		FastSort(nArr1, 8);
		cout << "第一个数组的最小的" << k << "个数为：";
		for (int i=0; i<k; i++)
		{
			cout << nArr1[i] << " ";
		}
		cout << endl;

		FastSort(nArr2, 8);
		cout << "第二个数组的最小的" << k << "个数为：";
		for (int i=0; i<k; i++)
		{
			cout << nArr2[i] << " ";
		}
		cout << endl;

		FastSort(nArr3, 8);
		cout << "第三个数组的最小的" << k << "个数为：";
		for (int i=0; i<k; i++)
		{
			cout << nArr3[i] << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

运行结果：

采用堆排序的代码：

#include "stdafx.h"
#include <iostream>
using namespace std;

//调整堆(大根堆)函数，待调整元素的下标nIndex，
void AdjustHeap(int nHeap[], int nLength, int nIndex)
{
	int key = nHeap[nIndex];//待调整元素的值
	for (int i=2*nIndex+1; i<nLength; i=2*i+1)
	{
		if (i+1 < nLength && (nHeap[i] < nHeap[i+1]))//有右孩子且右孩子的值比左孩子大
		{
			i++;//i指向表示较大孩子下标
		}
		if (nHeap[i] < key)//不需要调整
		{
			break;
		}
		nHeap[nIndex] = nHeap[i];
		nIndex = i;
	}
	nHeap[nIndex] = key;
}

//堆排序,从小到大
void HeapSort(int nArr[], int nLength)
{
	if (nArr != NULL && nLength > 0)
	{
		for (int i=nLength/2-1; i>=0; i--)
		{
			AdjustHeap(nArr, nLength, i);//调整为大根堆
		}

		for (int j=nLength-1; j>=0; j--)
		{
			int temp = nArr[j];
			nArr[j] = nArr[0];
			nArr[0] = temp;
			AdjustHeap(nArr, j, 0);
		}
	}
	else
	{
		return ;
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	int nArr1[8] = {4, 5, 1, 6, 2, 7, 3, 8};
	int nArr2[8] = {4, 5, 2, 6, 2, 5, 3, 5};
	int nArr3[8] = {1, 1, 1, 1, 1, 1, 1, 1};

	while (1)
	{
		int k = 0;
		cout << "请输入最小数的个数：";
		cin >> k;
		if (k == 0)
		{
			break;
		}

		HeapSort(nArr1, 8);
		cout << "第一个数组的最小的" << k << "个数为：";
		for (int i=0; i<k; i++)
		{
			cout << nArr1[i] << " ";
		}
		cout << endl;

		HeapSort(nArr2, 8);
		cout << "第二个数组的最小的" << k << "个数为：";
		for (int i=0; i<k; i++)
		{
			cout << nArr2[i] << " ";
		}
		cout << endl;

		HeapSort(nArr3, 8);
		cout << "第三个数组的最小的" << k << "个数为：";
		for (int i=0; i<k; i++)
		{
			cout << nArr3[i] << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

运行结果：

方法二：使用选择排序或冒泡排序，进行K次选择，可得到最小的k个数

时间复杂度：O(n*k)

选择排序代码：

#include "stdafx.h"
#include <iostream>
using namespace std;

//利用选择排序找到最小的k个数，进行k次选择即可
void SelectSort_KMinNum(int nArr[], int nLength, int k)
{
	if (nArr == NULL || nLength <= 0 || k>nLength)
    {
		cout << "输入有误！" << endl;
		return;
    }

	int nMin = 0;
	int nMinIndex = 0;
	for (int i=0; i<k; i++)//进行k次选择
	{
		nMin = nArr[i];
		nMinIndex = i;
		for (int j=i+1; j<nLength; j++)
		{
           if (nArr[j] < nMin)
           {
			   nMin = nArr[j];
			   nMinIndex = j;
           }
		}

		if (i != nMinIndex)
		{
			int temp = nArr[i];
			nArr[i] = nArr[nMinIndex];
			nArr[nMinIndex] = temp;
		}

		cout << nArr[i] << " ";
	}
	cout << endl;

}

int _tmain(int argc, _TCHAR* argv[])
{
	int nArr1[8] = {4, 5, 1, 6, 2, 7, 3, 8};
	int nArr2[8] = {4, 5, 2, 6, 2, 5, 3, 5};
	int nArr3[8] = {1, 1, 1, 1, 1, 1, 1, 1};

	while (1)
	{
		int k = 0;
		cout << "请输入最小数的个数：";
		cin >> k;
		if (k == 0)
		{
			break;
		}

		cout << "第一个数组的最小的" << k << "个数为：";
		SelectSort_KMinNum(nArr1, 8, k);		

        cout << "第二个数组的最小的" << k << "个数为：";
		SelectSort_KMinNum(nArr2, 8, k);		

        cout << "第三个数组的最小的" << k << "个数为：";
		SelectSort_KMinNum(nArr3, 8, k);
	}
    system("pause");
	return 0;
}

运行结果：

冒泡排序代码：

#include "stdafx.h"
#include <iostream>
using namespace std;

//利用冒泡排序找到最小的k个数，进行k次选择即可
void BubbleSort_KMinNum(int nArr[], int nLength, int k)
{
	if (nArr == NULL || nLength <= 0 || k>nLength)
	{
		cout << "输入有误！" << endl;
		return;
	}

	for (int i=1; i<=k; i++)//进行k次冒泡过程
	{
		for (int j=0; j<nLength-i; j++)
		{
			if (nArr[j] < nArr[j+1])
			{
				int temp = nArr[j];
				nArr[j] = nArr[j+1];
				nArr[j+1] = temp;
			}
		}	

		cout << nArr[nLength-i] << " ";
	}
	cout << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int nArr1[8] = {4, 5, 1, 6, 2, 7, 3, 8};
	int nArr2[8] = {4, 5, 2, 6, 2, 5, 3, 5};
	int nArr3[8] = {1, 1, 1, 1, 1, 1, 1, 1};

	while (1)
	{
		int k = 0;
		cout << "请输入最小数的个数：";
		cin >> k;
		if (k == 0)
		{
			break;
		}

		cout << "第一个数组的最小的" << k << "个数为：";
		BubbleSort_KMinNum(nArr1, 8, k);		

		cout << "第二个数组的最小的" << k << "个数为：";
		BubbleSort_KMinNum(nArr2, 8, k);		

		cout << "第三个数组的最小的" << k << "个数为：";
		BubbleSort_KMinNum(nArr3, 8, k);
	}
	system("pause");
	return 0;
}

运行结果：

方法三
、计数排序 + 数组实现 
适合数据量小的数据，不提倡使用

使用计数排序，另开辟一个数组，记录每个整数出现的次数，然后再从大到小取最大的 K 个。

代码：

#include "stdafx.h"
#include <iostream>
using namespace std;

//利用计数+数组找到最小的k个数
void CountArr_KMinNum(int nArr[], int nLength, int k)
{
	if (nArr == NULL || nLength <= 0 || k>nLength)
	{
		cout << "输入有误！" << endl;
		return;
	}

	int nMax = nArr[0];
	for (int i=1; i<nLength; i++)
	{
        if (nMax < nArr[i])
        {
			nMax = nArr[i];
        }
	}

	int *pArr = new int[nMax+1];//开辟一个数组
	memset(pArr, 0, (nMax+1)*sizeof(int));

	for (int j=0; j<nLength; j++)
	{
		pArr[nArr[j]]++;
	}

	int nCount = 0;
	for (int z=0; z<nMax+1; z++)
	{
		if (pArr[z]>0)
		{
			while ((pArr[z]--)>0)
			{
				if (nCount < k)
				{
					cout << z << " ";
					nCount++;
				}
				else
				{
                    break;
				}
			}
		}
	}

	delete []pArr;
	pArr = NULL;
    cout << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int nArr1[8] = {4, 5, 1, 6, 2, 7, 3, 8};
	int nArr2[8] = {4, 5, 2, 6, 2, 5, 3, 5};
	int nArr3[8] = {1, 1, 1, 1, 1, 1, 1, 1};

	while (1)
	{
		int k = 0;
		cout << "请输入最小数的个数：";
		cin >> k;
		if (k == 0)
		{
			break;
		}

		cout << "第一个数组的最小的" << k << "个数为：";
		CountArr_KMinNum(nArr1, 8, k);		

		cout << "第二个数组的最小的" << k << "个数为：";
		CountArr_KMinNum(nArr2, 8, k);		

		cout << "第三个数组的最小的" << k << "个数为：";
		CountArr_KMinNum(nArr3, 8, k);
	}
	system("pause");
	return 0;
}

运行结果：

方法四、利用STL中的map保存每个数出现的次数，找到K个数

时间复杂度O(n*logn)     空间复杂度O(n)

注意：1、不能使用CMap实现，因为Cmap不能根据key自动为其排序；2、map内部是由红黑树实现的，每次插入都是logn，总的复杂度为n*logn。

代码：

#include "stdafx.h"
#include <iostream>
#include <map>
using namespace std;

//利用map计数找到最小的k个数
void MapCount_KMinNum(int nArr[], int nLength, int k)
{
	if (nArr == NULL || nLength <= 0 || k>nLength)
	{
		cout << "输入有误！" << endl;
		return;
	}	

    map<int,int> countMap;

	for (int j=0; j<nLength; j++)
	{
		if (countMap[nArr[j]]==0)
		{
			countMap[nArr[j]] = 1;
		}
		else
		{
			countMap[nArr[j]]++;
		}
	}	

	int nCount = 0;
	for (map<int, int>::iterator itr=countMap.begin(); itr!=countMap.end(); itr++)
	{
		if (itr->second > 0)
		{
			while ((itr->second--) > 0)
			{
                if (nCount < k)
                {
					cout << itr->first << " ";
					nCount++;
                }
				else
				{
					break;
				}
			}
		}
	}
	cout << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int nArr1[8] = {4, 5, 1, 6, 2, 7, 3, 8};
	int nArr2[8] = {4, 5, 2, 6, 2, 5, 3, 5};
	int nArr3[8] = {1, 1, 1, 1, 1, 1, 1, 1};

	while (1)
	{
		int k = 0;
		cout << "请输入最小数的个数：";
		cin >> k;
		if (k == 0)
		{
			break;
		}

		cout << "第一个数组的最小的" << k << "个数为：";
		MapCount_KMinNum(nArr1, 8, k);		

		cout << "第二个数组的最小的" << k << "个数为：";
		MapCount_KMinNum(nArr2, 8, k);		

		cout << "第三个数组的最小的" << k << "个数为：";
		MapCount_KMinNum(nArr3, 8, k);
	}
	system("pause");
	return 0;
}

运行结果：

方法五、维护一个大小为k的大根堆，初始化为数组中前k个元素，调整为大根堆。对于数组中的剩下的数，判断与堆顶的大小。如果比堆顶大，则不需要改变原来的堆；如果比堆顶小，要将其替换堆顶的元素，调整为大根堆。

时间复杂度： O (N * log2 K )，算法只需扫描所有的数一次，调整堆的时间复杂度为O(log2K)

空间复杂度：O(k)，需一个大小为k 的堆。

代码：

#include "stdafx.h"
#include <iostream>
using namespace std;

//调整堆(大根堆)函数，待调整元素的下标nIndex，
void AdjustHeap(int nHeap[], int nLength, int nIndex)
{
	int key = nHeap[nIndex];//待调整元素的值
	for (int i=2*nIndex+1; i<nLength; i=2*i+1)
	{
		if (i+1 < nLength && (nHeap[i] < nHeap[i+1]))//有右孩子且右孩子的值比左孩子大
		{
			i++;//i指向表示较大孩子下标
		}
        if (nHeap[i] < key)//不需要调整
        {
            break;
        }
		nHeap[nIndex] = nHeap[i];
		nIndex = i;
	}
	nHeap[nIndex] = key;
}

//找到数组nArr中最小的k个数
int* MinKNum(int nArr[], int nLength, int k)
{
	if (nArr != NULL && nLength > 0 && k <= nLength)
	{
		//维护一个大小为k的大根堆,初始化为数组的前k个元素
		int *nHeap = new int[k];
        for (int i=0; i<k; i++)
        {
			nHeap[i] = nArr[i];
        }
		for (int t=k/2-1; t>=0; t--)
		{
			AdjustHeap(nHeap, k, t);//调整为大根堆
		}

        for (int j=k; j<nLength; j++)
        {
			if (nArr[j] < nHeap[0])//剩下的元素依次与堆顶元素进行比较，若比其小则替换堆顶元素
			{
               nHeap[0] = nArr[j];
			   AdjustHeap(nHeap, k, 0);
			}
        }
		return nHeap;
	}
	else
	{
		return NULL;
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	int nArr[8] = {4, 5, 1, 6, 2, 7, 3, 8};
	//int nArr[8] = {1, 2, 3, 4, 5, 6, 7, 8};
	//int nArr[8] = {2, 2, 2, 2, 2, 2, 2, 2};
	int k = 0;
	while (1)
	{
		cout << "请输入最小数的个数:";
		cin >> k;
		if (k == 0)//输入0表示程序结束
		{
			break;
		}
		int *p_nHeap = MinKNum(nArr, 8, k);
		cout << "最小的" << k << "个数为：";
		for (int i=0; i<k; i++)
		{
			cout << p_nHeap[i] << " ";
		}
		cout << endl;

		delete [] p_nHeap;
		p_nHeap = NULL;
	}	

	system("pause");
	return 0;
}

运行结果：