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; }