5.查找最小的 k 个元素（数组）
题目：输入 n 个整数，输出其中最小的 k 个。
例如输入 1，2，3，4，5，6，7 和 8 这 8 个数字，则最小的 4 个数字为 1，2，3 和 4。
算法里面学过查找第k小的元素的O（n）算法
试着实现了一下：
注意new 初始化二维数组的方式
int (* a)[5] = new int[8][5];
/*
5.查找最小的 k 个元素（数组）
题目：输入 n 个整数，输出其中最小的 k 个。
例如输入 1，2，3，4，5，6，7 和 8 这 8 个数字，则最小的 4 个数字为 1，2，3 和 4。
*/
#include <iostream>
#include <algorithm>
using namespace std;
bool compare(int a, int b) //降序排列
{
return a > b;
}
//找到 一共有 n个 元素的 数组S 中 第k小 的数字 整个算法中，对除以5后余下的数字都做了特殊处理
int Select(int * S, int k, int n)
{
if (n < 5) //对少于5个的做特殊处理
{
sort(S, S + n);
return S[k - 1];
}
int subn = n/5 + ((n % 5 == 0) ? 0 : 1);
int subnn = n/5;
int (* subS)[5] = new int[subn][5];
for (int i = 0; i < subnn; i++)
{
for (int j = 0; j < 5; j++)
{
subS[i][j] = S[i * 5 + j];
}
sort(subS[i], subS[i] + 5, compare); //5个一组,每组从大到小排序
}
for (int j = 0; j < n % 5; j++)
{
subS[subn - 1][j] = S[subn * 5 + j - 5];
}
sort(subS[subn - 1], subS[subn - 1] + n % 5, compare);
int * M = new int [subn];
for (int i = 0; i < subn; i++)
{
M[i] = subS[i][2]; //M 中存储每组数字的中位数
}
int Mn = subnn;
int m = Select(M, Mn/2 + (Mn % 2 == 0) ? 0 : 1, Mn);
delete [] M;
int * S1 = new int [n]; //存放小于等于m的数字
int * S2 = new int [n];
int S1n = 0; //记录有多少小于等于m的数字
int S2n = 0;
//找到相应的S1 与 S2中的元素
for (int i = 0; i < subnn; i++)
{
if (subS[i][2] <= m)
{
for (int j = 0; j < 5; j++)
{
if (j < 2)
{
if (subS[i][j] <= m)
{
S1[S1n++] = subS[i][j];
}
else
{
S2[S2n++] = subS[i][j];
}
}
else
{
S1[S1n++] = subS[i][j];
}
}
}
else
{
for (int j = 0; j < 5; j++)
{
if (j > 2)
{
if (subS[i][j] <= m)
{
S1[S1n++] = subS[i][j];
}
else
{
S2[S2n++] = subS[i][j];
}
}
else
{
S2[S2n++] = subS[i][j];
}
}
}
}
if (subnn != subn) //多余的数字特别处理
{
for (int j = 0; j < n % 5; j++)
{
if (subS[subn - 1][j] > m)
{
S2[S2n++] = subS[subn - 1][j];
}
else
{
S1[S1n++] = subS[subn - 1][j];
}
}
}
if (k == S1n)
{
delete [] S1;
delete [] S2;
return m;
}
else if (k < S1n)
{
return Select(S1, k, S1n);
}
else
{
return Select(S2, k - S1n, S2n);
}
delete [] S1;
delete [] S2;
}
int main()
{
int a[8] = {1,2,3,4,5,6,7,8};
int m = Select(a, 7, 8);
return 0;
}
不过，我的代码看起来好长，好难受啊...
网上有用堆做的，对堆不是很了解，要补一下知识。
看了用堆的方法的原理，理论上会比我现在实现的这个算法慢一点
方法是用堆维护k个最小元素
下面来自：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/02.01.md
解法二
咱们再进一步想想，题目没有要求最小的k个数有序，也没要求最后n-k个数有序。既然如此，就没有必要对所有元素进行排序。这时，咱们想到了用选择或交换排序，即：
1、遍历n个数，把最先遍历到的k个数存入到大小为k的数组中，假设它们即是最小的k个数；
2、对这k个数，利用选择或交换排序找到这k个元素中的最大值kmax（找最大值需要遍历这k个数，时间复杂度为O（k））；
3、继续遍历剩余n-k个数。假设每一次遍历到的新的元素的值为x，把x与kmax比较：如果x < kmax ，用x替换kmax，并回到第二步重新找出k个元素的数组中最大元素kmax‘；如果x >= kmax，则继续遍历不更新数组。
每次遍历，更新或不更新数组的所用的时间为O（k）或O（0）。故整趟下来，时间复杂度为n*O（k）=O（n*k）。
解法三
更好的办法是维护容量为k的最大堆，原理跟解法二的方法相似：
- 1、用容量为k的最大堆存储最先遍历到的k个数，同样假设它们即是最小的k个数；
- 2、堆中元素是有序的，令k1<k2<...<kmax（kmax设为最大堆中的最大元素）
- 3、遍历剩余n-k个数。假设每一次遍历到的新的元素的值为x，把x与堆顶元素kmax比较：如果
x < kmax，用x替换kmax，然后更新堆（用时logk）；否则不更新堆。
这样下来，总的时间复杂度:O（k+（n-k）*logk）=O（n*logk）。此方法得益于堆中进行查找和更新的时间复杂度均为：O(logk)（若使用解法二：在数组中找出最大元素，时间复杂度：O（k））。
堆的实现代码：来自http://www.cnblogs.com/panweishadow/p/3632639.html
public static void FindKMin(int[] sort, int k)
{
int[] heap = sort;
int rootIndex = k / 2 - 1;
while (rootIndex >= 0)
{
reheap(heap, rootIndex, k - 1);
rootIndex--;
}
for (int i = k, len=heap.Length; i < len; i++)
{
if (heap[i]<heap[0])
{
heap[0] = heap[i];
reheap(heap, 0, k - 1);
}
}
Console.WriteLine("The {0} min element =",k);
for (int i = 0; i < k; i++)
{
Console.Write(heap[i] + " ");
}
}
private static void reheap(int[] heap, int rootIndex, int lastInddex)
{
int orphan = heap[rootIndex];
bool done = false;
int leftIndex = rootIndex * 2 + 1;
while (!done && leftIndex <= lastInddex)
{
int largerIndex = leftIndex;
if (leftIndex+1 <= lastInddex)
{
int rightIndex = leftIndex + 1;
if (heap[rightIndex] > heap[leftIndex])
{
largerIndex = rightIndex;
}
}
if (orphan < heap[largerIndex])
{
heap[rootIndex] = heap[largerIndex];
rootIndex = largerIndex;
leftIndex = rootIndex * 2 + 1;
}
else
{
done = true;
}
}
heap[rootIndex] = orphan;
}