PTA 7-38 寻找大富翁（25 分）解法(C/C++)暴力快排/精准堆排 解法
7-38 寻找大富翁 (25分)
胡润研究院的调查显示，截至2017年底，中国个人资产超过1亿元的高净值人群达15万人。假设给出N个人的个人资产值，请快速找出资产排前M位的大富翁。
输入格式:
输入首先给出两个正整数N（≤10^6）和M（≤10），其中N为总人数，M为需要找出的大富翁数；接下来一行给出N个人的个人资产值，以百万元为单位，为不超过长整型范围的整数。数字间以空格分隔。
输出格式:
在一行内按非递增顺序输出资产排前M位的大富翁的个人资产值。数字间以空格分隔，但结尾不得有多余空格。
输入样例:
8 3
8 12 7 3 20 9 5 18
输出样例:
20 18 12坑点说明：
注意有可能M>N，此时按照常理应取M=N
实测输入数据（第二行数据）不超过int32位。
解法一：系统自带快速排序法（直接能想到的暴力解法）
C++版本：
#include
#include
#include
using namespace std;
typedef int ELE;
const size_t SIZE = 1000000;
ELE A[SIZE];
size_t N, M;
int main() {
scanf("%d %d\n", &N, &M);
M = min(N, M); //坑点先处理
for (size_t i = 0; i < N; i++){
scanf("%d", &A[i]);
}
sort(A, A+N, std::greater()); //降序排序
//输出M个数
printf("%d", A[0]); //第一名
for (size_t i = 1; i < M;++i) {
printf(" %d", A[i]);
}
// system("pause");
return 0;
}
C语言版本在附录（算法完全一致）
解法二：仅对前M名进行堆排序
由于输入的总数N最高可达10的6次方，但只求前M名的结果且M不超过10，能不能利用此减少处理的数据量呢？答案是肯定的，虽然输入N个数的操作不可能避免，但是可以将存储和排序的个数减少到M（M先取min(N,M)）。
只需建立M个的小根堆，先录入M个元素，后面的N-M个元素仅当大于堆顶（堆中最小者，即第M大），才替换堆顶并调整。最后堆中M个元素就是全部N个元素中的前M大。因为只求前M名，所以新输入的不比当前第M名大则丢弃！
有些程序员做法是排N个元素（最高达10^6）的堆排序，完全没利用上M很小的优势。同规模的堆排序本来就比快速排序慢！而且堆太大时cache命中率低下，访存速度就更慢了，会比暴力快排解法慢得多。
下面解法是用自编的小根堆而非优先队列，速度较快。其实只要默一遍堆排序向下调整这一个函数，就可以用于此题，因为此题不需要从堆尾插入元素，只需要更新堆顶，而C++自带的优先队列C++11版本的STL还不支持更新堆顶操作（强烈建议官方添加此操作~~汗）。
C++解法如下：
#include
#include
using namespace std;
typedef unsigned int U32;
typedef int ELE;
typedef const ELE & ELE_CR; //_CR表示常引用
const U32 SIZE = 11;
ELE H[SIZE]; //Heap Sort
U32 sizeH = 0;
bool cmp(ELE_CR parent, ELE_CR child) {
return parent< child; //小根堆（必须父<=子）
}
void downShift(int i);
int N, M;
int main() {
scanf("%d %d\n", &N, &M);
M = min(N,M); //坑点先处理
//先输入M个
for (sizeH = 0; sizeH < M; ) {
scanf("%d", &H[++sizeH]); //注意堆排序H[0]不算节点
}
//建堆，倒序遍历每个非叶节点向下调整即可。
for (int i = sizeH / 2; i>0; --i) {
downShift(i); //向下调整
}
//再输入 N-M个
for (int i = N - M; i-- > 0;) {
scanf("%d", &H[0]);
if (H[0] > H[1]) { //比堆顶（第M名）大
H[1] = H[0]; //替代掉
downShift(1); //向下调整
}
}
sort(H + 1, H + 1 + M); //前M名升序排序
printf("%d",H[M]); //倒序输出M个
for (int i = M-1; i >= 1; --i) {
printf(" %d", H[i]);
}
// system("pause");
return 0;
}
void downShift(int i) {
ELE key = H[i]; //虚交换——备份（key作为值，H[i]作为地址）
for (int j; (j = 2 * i) <= sizeH; i = j) {
if (j < sizeH && cmp(H[j + 1], H[j]))++j; //左右两个子节点取更"父"者
if (cmp(H[j], key))H[i] = H[j]; //虚交换（父子节点）
else break;
}
H[i] = key; //虚交换——复原
}
此解法比暴力快排解法执行快20%左右（OJ平台执行时间会有波动，需要多次交叉测量取平均），其实一大半的时间浪费在IO上，如果M超过1000，估计怎么优化都还是暴力快排更快吧。
附录：
暴力快排C语言解法：
#include
#include
typedef int ELE;
typedef const void* CR;
#define INT(pointer) (*((int*)pointer))
int cmp(CR a, CR b) { //降序排序
return INT(b) - INT(a);
}
#define FOR(I,S,E) for(int I=(S);I<(E);I++)
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#define SIZE 1000000
ELE A[SIZE];
int N, M;
int main() {
scanf("%d %d\n", &N, &M);
M = MIN(N, M); //坑点先处理
FOR(i,0,N) {
scanf("%d", &A[i]);
}
qsort(A, N, sizeof(ELE), cmp); //降序排序
//输出M个数
printf("%d", A[0]);
FOR(i,1,M) {
printf(" %d", A[i]);
}
// system("pause");
return 0;
}
精准堆排序C语言版：
#include
#include
typedef unsigned int U32;
typedef int ELE;
typedef const void* CR;
#define INT(pointer) (*((int*)pointer))
int cmp(CR a, CR b) { return INT(a) - INT(b); }
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#define SIZE 11
ELE H[SIZE]; //Heap Sort
U32 sizeH = 0;
#define CMP(PARENT,CHILD) ((PARENT)<(CHILD))//小根堆（必须父<=子）
void downShift(int i);
int N, M;
int main() {
scanf("%d %d\n", &N, &M);
M = MIN(N,M); //坑点先处理
//先输入M个
for (sizeH = 0; sizeH < M; ) {
scanf("%d", &H[++sizeH]); //注意堆排序H[0]不算节点
}
//建堆，倒序遍历每个非叶节点向下调整即可。
for (int i = sizeH / 2; i>0; --i) {
downShift(i); //向下调整
}
//再输入 N-M个
for (int i = N - M; i-- > 0;) {
scanf("%d", &H[0]);
if (H[0] > H[1]) { //比堆顶（第M名）大
H[1] = H[0]; //替代掉
downShift(1); //向下调整
}
}
qsort(H + 1, M, sizeof(ELE), cmp); //前M名升序
printf("%d",H[M]);
for (int i = M; i-- > 1;) {
printf(" %d", H[i]);
}
// system("pause");
return 0;
}
void downShift(int i) {
ELE key = H[i];
for (int j; (j = 2 * i) <= sizeH; i = j) {
if (j < sizeH && CMP(H[j + 1], H[j]))++j;
if (CMP(H[j], key))H[i] = H[j];
else break;
}
H[i] = key;
}