归并排序poj2299

 

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 19252		Accepted: 6828

Description

In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input sequence 
9 1 0 5 4 ,
Ultra-QuickSort produces the output 
0 1 4 5 9 .
Your task is to determine how many swap operations Ultra-QuickSort needs to perform in order to sort a given input sequence.

Input

The input contains several test cases. Every test case begins with a line that contains a single integer n < 500,000 -- the length of the input sequence. Each of the the following n lines contains a single integer 0 ≤ a[i] ≤ 999,999,999, the i-th input sequence element. Input is terminated by a sequence of length n = 0. This sequence must not be processed.

Output

For every input sequence, your program prints a single line containing an integer number op, the minimum number of swap operations necessary to sort the given input sequence.

Sample Input

5
9
1
0
5
4
3
1
2
3
0

Sample Output

6
0

1.问题分析

应用归并排序方法。

归并排序nlog(n)的排序速度很不错，而求在排序的过程中，有个归并过程merge()，
这里是将两个有序数列归并为一个有序数列，在归并的过程中，很容易就能够计算逆序对个数，所以可以很快解决这个问题。
 
即：对于数列[l, mid] [mid + 1, r]的合并，i 从l开始循环，j从mid + 1开始循环，如果遇到a[i] > a[j] 则出现逆序，可以将a[j]放入辅助数组，同时j++，那么和a[j]逆序的数就有mid-i+1个，因为序列是有序的[i, mid]的所有的数都是大于a[j]的。

2.应用到的算法
比较冒泡排序和归并排序：
//-----冒泡排序----- void bubble_sort(int a[],int n) { for(i=n-1,change=TRUE;i>=1&&change;--i) { change=FALSE; for(j=0;j<i;++j) { if(a[j]>a[j+1]) { a[j]<-->a[j+1];change = TRUE; } } } } 
T(n)=O(n^2)
//----------归并排序--------- MERGE-SORT(A, p, r) 1 if p < r 2 then q ← ⌊(p + r)/2⌋ 3 MERGE-SORT(A, p, q) 4 MERGE-SORT(A, q + 1, r) 5 MERGE(A, p, q, r) MERGE(A, p, q, r) 1 n1 ← q - p + 1 2 n2 ← r - q 3 create arrays L[1 ‥ n1 + 1] and R[1 ‥ n2 + 1] 4 for i ← 1 to n1 5 do L[i] ← A[p + i - 1] 6 for j ← 1 to n2 7 do R[j] ← A[q + j] 8 L[n1 + 1] ← ∞ 9 R[n2 + 1] ← ∞ 10 i ← 1 11 j ← 1 12 for k ← p to r 13 do if L[i] ≤ R[j] 14 then A[k] ← L[i] 15 i ← i + 1 16 else A[k] ← R[j] 17 j ← j + 1 
T(n)=O(nlog(n))

3.代码：
#include <stdio.h> #include <malloc.h> int L[500001]; int R[500001]; int a[500001]; long long num=0; void merge(int a[],int p,int q,int r) { int i,j,k; int n1=q-p+1; int n2=r-q; for(i=1;i<=n1;i++) { L[i]=a[p+i-1]; } for(j=1;j<=n2;j++) { R[j]=a[q+j]; } L[n1+1]=0x7fffffff; R[n2+1]=0x7fffffff; i=1;j=1; for(k=p;k<=r;k++) { if(L[i]<=R[j]) { a[k]=L[i]; i++; } else { a[k]=R[j]; j++; num+=n1-i+1; } } } void merge_sort(int a[],int p,int r) { int q; if(p<r) { q=(p+r)/2; merge_sort(a,p,q); merge_sort(a,q+1,r); merge(a,p,q,r); } } int main() { int n,i; while(scanf("%d",&n)&&n!=0) { num=0; for(i=0;i<n;i++) { scanf("%d",&a[i]); } merge_sort(a,0,n-1); printf("%lld/n",num); } return 0; } 


4.遇到的问题及解决
（1）为什么num要用long long型申请？
假设n=500000个数刚好是从大到小的一个完全逆序，则num=(500000+1)*500000/2这个数的范围超出了long 所能表示的范围
其实也可以申请为_int64
（2）main()中merge_sort函数的参数传递要正确