PAT-B1035/A1089-Insert or Merge(25)

题目

根据维基百科的定义：

插入排序是迭代算法，逐一获得输入数据，逐步产生有序的输出序列。每步迭代中，算法从输入序列中取出一元素，将之插入有序序列中正确的位置。如此迭代直到全部元素有序。

归并排序进行如下迭代操作：首先将原始序列看成 N 个只包含 1 个元素的有序子序列，然后每次迭代归并两个相邻的有序子序列，直到最后只剩下 1 个有序的序列。

现给定原始序列和由某排序算法产生的中间序列，请你判断该算法究竟是哪种排序算法？

输入输出

输入格式：

输入在第一行给出正整数 N (≤100)；随后一行给出原始序列的 N 个整数；最后一行给出由某排序算法产生的中间序列。这里假设排序的目标序列是升序。数字间以空格分隔。

输出格式：

首先在第 1 行中输出Insertion Sort表示插入排序、或Merge Sort表示归并排序；然后在第 2 行中输出用该排序算法再迭代一轮的结果序列。题目保证每组测试的结果是唯一的。数字间以空格分隔，且行首尾不得有多余空格。

输入样例 1：

10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0

输出样例 1：

Insertion Sort
1 2 3 5 7 8 9 4 6 0

输入样例 2：

10
3 1 2 8 7 5 9 4 0 6
1 3 2 8 5 7 4 9 0 6

输出样例 2：

Merge Sort
1 2 3 8 4 5 7 9 0 6

题目信息

作者：CHEN, Yue

单位：浙江大学

代码长度限制：16 KB

时间限制：200 ms

内存限制：64 MB

题目知识点

Two Pointer的“序列合并问题”

归并排序

题目分析

把 原始序列存为A，把第二个序列存为 B，分别对原始序列进行排序，在排序过程中看哪个排序方式过程中出现了序列B，就输出哪个序列，并用该方法再进行一轮排序

注意点

①：归并排序的步长 和 插入排序排到了第几个数 都要设置成静态，这是为了方便确定了排序方法之后在进行一轮排序是，能够继续按照之前的状态进行

②：由于Java的数组是引用类型，所以函数中数组发生了改变就会改变原数组，因此两种排序不可以用同一个数组

③：每一轮排序中都要判断一下两个序列是否相等，如果想等就返回。但是不可直接返回，因为之后还要再进行一轮排序，直接返回的话下次排序还是停留在这一轮，所以要把对应排序的初始状态重置到下一轮

④：不知道为什么，我提交的时候PAT不支持 Arrays.compare()，所以需要专门写一个函数来比较两个数组是否相等

Java代码

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;

class Main{
	
	public static int[] B;	
	public static int step=2;	// 注意点①
	public static int insertCount = 1;	// 注意点①
	
	public static void main(String[] args) throws Exception{
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		bf.readLine();
		String[] strArr = bf.readLine().split(" ");
		int[] A = new int[strArr.length];
		B = new int[strArr.length];
		for(int i=0; i<A.length; i++) {
			A[i] = Integer.parseInt(strArr[i]);
		}
		strArr = bf.readLine().split(" ");
		for(int i=0; i<B.length; i++) {
			B[i] = Integer.parseInt(strArr[i]);
		}
		int[] C = A.clone();	// 注意点②
		boolean isMerge = MergeSort(A, false);
		InsertionSort(C, false);
		if(isMerge) {
			System.out.println("Merge Sort");
			MergeSort(A, true);
		}else {
			System.out.println("Insertion Sort");
			InsertionSort(C, true);
			A = C;
		}
		for(int i=0; i<A.length-1; i++) {
			System.out.print(A[i]+" ");
		}
		System.out.println(A[A.length - 1]);
	}
	
	
	//合并数组的两端位置 相邻
	public static void merge(int[] A, int left1, int right1, int left2, int right2) {
		int i = left1, j = left2;
		int[] temp = new int[right2 - left1 + 1];
		int index = 0;
		while(i <= right1 && j <= right2) {
			if(A[i] <= A[j]) {
				temp[index++] = A[i++]; 
			}else {
				temp[index++] = A[j++];
			}
		}
		while(i <= right1)
			temp[index++] = A[i++];
		while(j <= right2)
			temp[index++] = A[j++];
		
		for(int i1=0; i1<temp.length; i1++) {
			A[left1 + i1] = temp[i1];
		}
	}
	
	// 归并排序 返回比较结果
	public static boolean MergeSort(int[] A, boolean onceTag) {
		for(; step/2<=A.length; step*=2) {
			for(int i=0; i<A.length; i+=step) {
	            int mid = i - 1 + step/2;
	            if(mid < A.length - 1){	// 判断右子区间是否有元素，有就合并
	                // 左子区间[i, mid], 右子区间为[mid+1,Math.min(i+step, n)] (这是为了防止超过步长）
	                merge(A, i, mid, mid+1, Math.min(i - 1 + step, A.length-1));
	            }
			}
			if(onceTag == true)
				break;
			if( compare(A, B) == 0 ) {
				step *= 2; // 注意点③
				return true;
			}
		}
		return false;
	}

	// 插入排序
	public static boolean InsertionSort(int[] A, boolean onceTage) {
		for(; insertCount < A.length; insertCount++) {
			int temp = A[insertCount], j=insertCount;
			while(j>0 && A[j-1] > temp) {
				A[j] = A[j-1]; 
				j--;
			}
			A[j] = temp;
			if(onceTage == true)
				return false;
			if(compare(A, B)==0) {
				insertCount++; //注意点③
				return true;
			}
		}
		return false;
	}
    
    // 注意点④
	public static int compare(int[] A, int[] B) {
		for(int i=0; i<A.length; i++) {
			if(A[i] != B[i])
				return -1;
		}
		return 0;
	}
}