Ultra-QuickSort (POJ - 2299)

Ultra-QuickSort

 POJ - 2299 

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

思路:

• 题目的意思就是让你求冒泡排序的次数
• 要求冒泡排序的次数其实其实就是求出该数组中逆序对的数量
• 要求逆序对的数量可以使用归并排序来做

AcCode:

import java.util.Scanner;

public class Main{
	public static void main(String[] args) {
		//求冒泡排序交换的次数就是求该数组中有多对逆序对
		//求有对逆序对可以使用归并排序来求得
		Scanner in = new Scanner(System.in);
		while(in.hasNext()) {
			int n = in.nextInt();
			if(n==0)break;
			count = 0;
			int[] nums = new int[n];
			tempNums = new int[n];
			for (int i = 0; i < nums.length; i++) {
				nums[i] = in.nextInt();
			}
			MergeSort(nums,0,nums.length-1);
			System.out.println(count);
		}
		
		
	}
	
	private static int[] tempNums =  null;
	
	private static void MergeSort(int[] nums, int i, int j) {
		if(i<j) {
			int mid = i+((j-i)>>1);
			//对前半段进行排序
			MergeSort(nums, i, mid);
			//对后半段进行排序
			MergeSort(nums, mid+1, j);
			//归并
			Merge(nums,i,j,mid);
		}
	}

	private static void Merge(int[] nums, int i, int j, int mid) {
		for (int k = i; k < j+1; k++) {
			tempNums[k] = nums[k];
		}
		int k = mid+1;
		int index = i;
		while(i<=mid && k<=j) {
			if(tempNums[i]<=tempNums[k]) {
				nums[index++] = tempNums[i++];
			}else {
				nums[index++] = tempNums[k++];
				count = count + mid - i + 1;
			}
		}
		while(i<=mid) {
			nums[index++] = tempNums[i];
			i++;
		}
		while(k<=j) {
			nums[index++] = tempNums[k];
			k++;
		}
		
	}

	public static long count = 0;
}