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