根据维基百科的定义:
插入排序是迭代算法,逐一获得输入数据,逐步产生有序的输出序列。每步迭代中,算法从输入序列中取出一元素,将之插入有序序列中正确的位置。如此迭代直到全部元素有序。
归并排序进行如下迭代操作:首先将原始序列看成 N 个只包含 1 个元素的有序子序列,然后每次迭代归并两个相邻的有序子序列,直到最后只剩下 1 个有序的序列。
现给定原始序列和由某排序算法产生的中间序列,请你判断该算法究竟是哪种排序算法?
输入在第一行给出正整数 N (≤100);随后一行给出原始序列的 N 个整数;最后一行给出由某排序算法产生的中间序列。这里假设排序的目标序列是升序。数字间以空格分隔。
首先在第 1 行中输出Insertion Sort
表示插入排序、或Merge Sort
表示归并排序;然后在第 2 行中输出用该排序算法再迭代一轮的结果序列。题目保证每组测试的结果是唯一的。数字间以空格分隔,且行首尾不得有多余空格。
10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0
Insertion Sort
1 2 3 5 7 8 9 4 6 0
10
3 1 2 8 7 5 9 4 0 6
1 3 2 8 5 7 4 9 0 6
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(),所以需要专门写一个函数来比较两个数组是否相等
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;
}
}