数据结构实验之排序四：寻找大富翁

1. 数据结构实验之排序四：寻找大富翁

   Time Limit: 200MS Memory Limit: 512KB
   SubmitStatistic

   Problem Description

   2015胡润全球财富榜调查显示，个人资产在1000万以上的高净值人群达到200万人，假设给出N个人的个人资产值，请你快速找出排前M位的大富翁。

   Input

   首先输入两个正整数N( N ≤ 10^6)和M(M ≤ 10)，其中N为总人数，M为需要找出的大富翁数目，接下来给出N个人的个人资产，以万元为单位，个人资产数字为正整数，数字间以空格分隔。

   Output

   一行数据，按降序输出资产排前M位的大富翁的个人资产值，数字间以空格分隔，行末不得有多余空格。

    

   Example Input

   6 312 6 56 23 188 60

   Example Output

   188 60 56

   Hint

   请用堆排序完成。 

   #include <stdio.h>   //头文件只有一个防超时  
2.   
3. int h[20];//用来存放堆的数组  
4. int m;     //堆的大小  
5.   
6. //交换函数，用来交换堆中的两个元素的值  
7. void Swap(int x, int y)  
8. {  
9.     int t;  
10.     t = h[x];  
11.     h[x] = h[y];  
12.     h[y] = t;  
13. }  
14.   
15. //向下调整函数  
16. void Siftdown(int i)  //传入一个需要向下调整的节点的编号i，这里传入1，即  
17. //从堆顶开始向下调整；  
18. {  
19.     int t, flag=0;   //flag用来标记是否需要继续向下调整  
20.     //当i结点有孩子（其实是至少有左孩子）并且有需要继续调整的时候循环就执行  
21.     while(i*2 <= m && flag == 0)  
22.     {  
23.         //首先判断它和左孩子的关系，并用t记录值较小的结点的编号  
24.         if(h[i] > h[i*2])  
25.             t = i*2;  
26.         else  
27.             t = i;  
28.         //如果它有右孩子，再对右孩子进行讨论  
29.         if(i*2+1 <= m)  
30.         {  
31.             //假如右孩子的值更小，更新较小的节点编号  
32.             if(h[t] > h[i*2+1])  
33.                 t = i*2+1;  
34.         }  
35.         //如果发现最小的结点编号不是自己，说明子节点中有比父节点更小的  
36.         if(t != i)  
37.         {  
38.             Swap(t, i);   //交换他们  
39.             i = t;        //更新i为刚才与它交换的孩子结点的编号，便于接下来继续向下调整  
40.         }  
41.         else  
42.             flag = 1;     //否则说明当前的父节点已经比两个子节点都要小了，不需要再进行调整了  
43.     }  
44. }  
45.   
46. void heapsort()     //堆排序  
47. {  
48.     while(m > 1)  
49.     {  
50.         Swap(m, 1);  
51.         m--;  
52.         Siftdown(m);  
53.     }  
54. }  
55.   
56. int main()  
57. {  
58.     int num, n, i, j;  
59.     scanf("%d%d", &num, &m);  
60.     for(i = 1; i <= m; i++)  
61.         scanf("%d", &h[i]);  
62.     n = m;  
63.     for(i = m/2; i >= 1; i--)    //建m个元素的最小堆  
64.         Siftdown(i);  
65.     for(i = m+1; i <= num; i++)  //然后从第m+1个元素开始，与堆顶元素比较，  
66.         //如果比堆顶的元素小，那这个数就不要了，  
67.     {  
68.         int x;  
69.         scanf("%d", &x);  
70.         if(x > h[1])  
71.         {  
72.             //如果比堆顶的元素大，那就舍弃当前堆顶而  
73.             //将这个数作为新的堆顶，并维护最小堆的性质  
74.             h[1] = x;  
75.             for(j = m/2; j >= 1; j--)  
76.                 Siftdown(j);  
77.         }  
78.     }  
79.     heapsort();              //堆排序  
80.     for(i = 1; i <= n; i++)  
81.         if(i != n)  
82.             printf("%d ", h[i]);  
83.         else  
84.             printf("%d\n", h[i]);  
85.     return 0;  
86. }  

1. #include <stdio.h>   //头文件只有一个防超时  
2.   
3. int h[20];//用来存放堆的数组  
4. int m;     //堆的大小  
5.   
6. //交换函数，用来交换堆中的两个元素的值  
7. void Swap(int x, int y)  
8. {  
9.     int t;  
10.     t = h[x];  
11.     h[x] = h[y];  
12.     h[y] = t;  
13. }  
14.   
15. //向下调整函数  
16. void Siftdown(int i)  //传入一个需要向下调整的节点的编号i，这里传入1，即  
17. //从堆顶开始向下调整；  
18. {  
19.     int t, flag=0;   //flag用来标记是否需要继续向下调整  
20.     //当i结点有孩子（其实是至少有左孩子）并且有需要继续调整的时候循环就执行  
21.     while(i*2 <= m && flag == 0)  
22.     {  
23.         //首先判断它和左孩子的关系，并用t记录值较小的结点的编号  
24.         if(h[i] > h[i*2])  
25.             t = i*2;  
26.         else  
27.             t = i;  
28.         //如果它有右孩子，再对右孩子进行讨论  
29.         if(i*2+1 <= m)  
30.         {  
31.             //假如右孩子的值更小，更新较小的节点编号  
32.             if(h[t] > h[i*2+1])  
33.                 t = i*2+1;  
34.         }  
35.         //如果发现最小的结点编号不是自己，说明子节点中有比父节点更小的  
36.         if(t != i)  
37.         {  
38.             Swap(t, i);   //交换他们  
39.             i = t;        //更新i为刚才与它交换的孩子结点的编号，便于接下来继续向下调整  
40.         }  
41.         else  
42.             flag = 1;     //否则说明当前的父节点已经比两个子节点都要小了，不需要再进行调整了  
43.     }  
44. }  
45.   
46. void heapsort()     //堆排序  
47. {  
48.     while(m > 1)  
49.     {  
50.         Swap(m, 1);  
51.         m--;  
52.         Siftdown(m);  
53.     }  
54. }  
55.   
56. int main()  
57. {  
58.     int num, n, i, j;  
59.     scanf("%d%d", &num, &m);  
60.     for(i = 1; i <= m; i++)  
61.         scanf("%d", &h[i]);  
62.     n = m;  
63.     for(i = m/2; i >= 1; i--)    //建m个元素的最小堆  
64.         Siftdown(i);  
65.     for(i = m+1; i <= num; i++)  //然后从第m+1个元素开始，与堆顶元素比较，  
66.         //如果比堆顶的元素小，那这个数就不要了，  
67.     {  
68.         int x;  
69.         scanf("%d", &x);  
70.         if(x > h[1])  
71.         {  
72.             //如果比堆顶的元素大，那就舍弃当前堆顶而  
73.             //将这个数作为新的堆顶，并维护最小堆的性质  
74.             h[1] = x;  
75.             for(j = m/2; j >= 1; j--)  
76.                 Siftdown(j);  
77.         }  
78.     }  
79.     heapsort();              //堆排序  
80.     for(i = 1; i <= n; i++)  
81.         if(i != n)  
82.             printf("%d ", h[i]);  
83.         else  
84.             printf("%d\n", h[i]);  
85.     return 0;  
86. }