poj2388——Who's in the Middle

题目大意：给出奇数个奶牛的产奶量，找出他们的中位数

输入：奶牛个数N (1 <= N < 10,000) 

           第i个奶牛的产奶量(1..1,000,000)

输出：中位数

分析：可以直接用sort函数，也可以用快排、归并、堆排序，但是注意不要用冒泡、选择排序、直接排序等时间复杂度为O(N²)的排序方法

代码：

直接sort转载自http://blog.csdn.net/riverflowrand/article/details/52594833

1. #include <iostream>  
2. #include <algorithm>  
3.   
4. using namespace std;  
5.   
6. int n;  
7. int d[10005];  
8.   
9. int main() {  
10.       
11.     while(cin >> n) {  
12.           
13.         for(int i=0; i<n; i++)  
14.             cin >> d[i];  
15.               
16.         sort(d, d+n);  
17.           
18.         cout << d[(n-1)/2];  
19.     }  
20.       
21.     return 0;  
22. }

快排、归并、堆排序转载自http://blog.csdn.net/ltyqljhwcm/article/details/52469329

1.快排：选数据第一个作为pivot，设两个指针i和j，i指向数据头不断向右移直到所指数据比pivot大，j指向数据尾不断向左移直到所指数据比pivot小，此时比较ij，如果i<j，则交换ij所指数据，否则就将j所指数据与pivot交换

1. #include"iostream"  
2. #include"cstdio"  
3. #include"cstring"  
4. #define N 10010  
5.   
6. using namespace std;  
7.   
8. int data[N];  
9. int n;  
10.   
11. void quicksort(int left,int right)  
12. {  
13.     if(left>=right) return ;  
14.     else  
15.     {  
16.         int i=left;  
17.         int j=right;  
18.         int temp=data[left];  
19.         while(i!=j)  
20.         {  
21.             while(i<j&&data[j]>=temp) j--;  
22.             while(i<j&&data[i]<=temp) i++;  
23.             if(i!=j)  
24.             {  
25.                 int t=data[i];  
26.                 data[i]=data[j];  
27.                 data[j]=t;  
28.             }  
29.         }  
30.         data[left]=data[i];  
31.         data[i]=temp;  
32.         quicksort(left,i-1);  
33.         quicksort(i+1,right);  
34.         return ;  
35.     }  
36. }  
37.   
38. int main()  
39. {  
40.     scanf("%d",&n);  
41.     for(int i=1;i<=n;i++) scanf("%d",&data[i]);  
42.     quicksort(1,n);  
43.     printf("%d\n",data[(n+1)/2]);  
44.     return 0;  
45. }

2.归并：将一串数据的左半部分存入s1[]中，右半部分存入s2[]中，比较s1与s2的每一位，将较小的一个存入data[]中，且较小的数所在的部分指针后移

1. #include"iostream"  
2. #include"cstdio"  
3. #include"cstring"  
4. #define N 10010  
5. #define inf 99999999  
6.   
7. using namespace std;  
8.   
9. int data[N];  
10. int n;  
11.   
12. void mergesort(int left,int mid,int right)  
13. {  
14.     int n1=mid-left+1;  
15.     int n2=right-mid;  
16.     int s1[n1+2];  
17.     int s2[n2+2];  
18.     int i,j;  
19.     for(i=left;i<=mid;i++) s1[i-left+1]=data[i];  
20.     for(j=mid+1;j<=right;j++) s2[j-mid]=data[j];  
21.     i=j=1;  
22.     s1[n1+1]=s2[n2+1]=inf;  
23.     for(int k=left;k<=right;k++)  
24.     {  
25.         if(s1[i]>s2[j]) data[k]=s2[j++];  
26.         else data[k]=s1[i++];  
27.     }   
28. }  
29.   
30. void merge(int left,int right)  
31. {  
32.     if(left>=right) return ;  
33.     else  
34.     {  
35.         int mid=(left+right)/2;  
36.         merge(left,mid);  
37.         merge(mid+1,right);  
38.         mergesort(left,mid,right);  
39.     }  
40. }  
41.   
42. int main()  
43. {  
44.     scanf("%d",&n);  
45.     for(int i=1;i<=n;i++) scanf("%d",&data[i]);  
46.     merge(1,n);  
47.     printf("%d\n",data[(n+1)/2]);  
48.     return 0;  
49. } 

3.堆排序：建堆调整成最小堆，最后得到的是降序排列。排序过程：将堆顶与堆尾交换并删掉堆尾重新调整堆。

1. #include"iostream"  
2. #include"cstdio"  
3. #include"cstring"  
4. #define N 10010  
5.   
6. using namespace std;  
7.   
8. int data[N];  
9. int n;  
10. int heap[N];  
11. int heapnum;  
12.   
13. void swap(int x,int y)  
14. {  
15.     int t=data[x];  
16.     data[x]=data[y];  
17.     data[y]=t;  
18. }  
19.   
20. void siftdown(int i)  
21. {  
22.     int t;  
23.     while(i*2<=heapnum)  
24.     {  
25.         if(data[heap[i]]>data[heap[i*2]]) t=i*2;  
26.         else t=i;  
27.         if(i*2+1<=heapnum&&data[heap[i*2+1]]<data[heap[t]]) t=i*2+1;  
28.         if(i!=t)  
29.         {  
30.             swap(i,t);  
31.             i=t;  
32.         }  
33.         else break;  
34.     }  
35. }  
36.   
37. void heapsort()  
38. {  
39.     for(int i=1;i<=n-1;i++)  
40.     {  
41.         swap(1,heapnum);  
42.         heapnum--;  
43.         siftdown(1);  
44.     }  
45. }  
46.   
47. int main()  
48. {  
49.     scanf("%d",&n);  
50.     for(int i=1;i<=n;i++)  
51.     {  
52.         scanf("%d",&data[i]);  
53.         heap[i]=i;  
54.     }  
55.     heapnum=n;  
56.     for(int i=n/2;i>=1;i--) siftdown(i);  
57.     heapsort();  
58.     printf("%d\n",data[(n+1)/2]);  
59.     return 0;  
60. }