1089. Insert or Merge (25)

题目如下：

According to Wikipedia:

Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. Each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts
it there. It repeats until no input elements remain.

Merge sort works as follows: Divide the unsorted list into N sublists, each containing 1 element (a list of 1 element is considered sorted). Then repeatedly merge two adjacent sublists to produce new sorted sublists until there is only 1 sublist
remaining.

Now given the initial sequence of integers, together with a sequence which is a result of several iterations of some sorting method, can you tell which sorting method we are using?

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (<=100). Then in the next line, N integers are given as the initial sequence. The last line contains the partially sorted sequence of the N numbers. It is assumed
that the target sequence is always ascending. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print in the first line either "Insertion Sort" or "Merge Sort" to indicate the method used to obtain the partial result. Then run this method for one more iteration and output in the second line the resulting sequence. It is guaranteed
that the answer is unique for each test case. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

Sample Input 1:

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

Sample Output 1:

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

Sample Input 2:

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

Sample Output 2:

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

题目要求对给定序列的排序过程中序列进行处理，判断出是归并排序还是插入排序，并且要输出再进行一次此种排序后的结果。

【方法一】

要判断插入排序和归并排序，只需要看有序位置的不同，归并排序是分组有序，而插入排序是从前到后部分有序，通过这一特性，可以去找序列中的最小有序对，例如题目给出的第二组数据1 3 2 8 5 7 4 9 0 6，我们在1 3这个子序列得到有序子序列长度为2，向后处理可以发现每2个组成的子序列都是有序的，并且两两之间无序，因此是归并排序的特征。看第一组数据 1 2 3 7 8 5 9 4 6 0，如果从1 2 3 判断长为3的有序对，发现不满足。再尝试2为长度的，依然不满足，因此不是归并排序，而从前到后部分有序，因此是插入排序。

这时一种区分两种排序的方法，通过此种方法区分后再调用相应的排序函数，利用vector的==（系统自带）来判断序列的吻合性，然后再进行一步即可。

【方法二】

将插入排序拆分成按步进行，归并排序也采用非递归形式，非递归归并通过step=1开始，从长度为1的小区间开始归并，每次step+1。为了合并小区间，可以利用系统的inplace_merge函数，只要指定子序列的迭代器的头、中、尾，即可归并两序列。

此方法不必像方法一那样判断，而是先执行插入排序，找序列吻合，找到则再排输出，否则再尝试归并，这个方法比较简单，我比较完整的参考了zzyazzy的代码，如下：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

bool perInsertSort(vector<int> &src,vector<int> &dest,int start)
{
     int pos = start;
	 int poit = src[start];
	 for(int j= start -1;j>=0;--j){//找出插入位置
		 if(src[j] > poit) {
               pos = j;
		 }else{
			   break;
		 }
	 }
	 for(int j=start -1;j>=pos;--j){
		 src[j+1]=src[j];
	 }
	 src[pos]=poit;
	 if(src==dest) return true;
	 return false;
}

void mergeSort(vector<int> &src,int step)
{
	int len = src.size();
	if(step >= len) return ;//子区间的长度已经大于src的长度
	int i = 0;
	while(i<len){
		vector<int>::iterator iter = src.begin();
		int start = i;
		int middle = i+step;
		int end = middle+step;
		middle =(middle >= len ? len:middle);
		end = (end >= len ? len:end);
		inplace_merge(iter+start,iter+middle,iter+end);
	    i=end;
	}
}

void print(const vector<int> &src)
{
	bool first = true;
	for(int i=0;i<src.size();++i){
		if(first){
			cout<<src[i];
			first = false;
		}else{
			cout<<" "<<src[i];
		}
	}
}

int main()
{
	int n;
	cin>>n;
	int x;
	vector<int> src,dest;
	int repeat = n;
	while(repeat --){
		cin>>x;
		src.push_back(x);
	}
	repeat = n;
	while(repeat --){
		cin>>x;
		dest.push_back(x);
	}
	vector<int> temp(src.begin(),src.end()); // 备份原来的数据，如果不是插入，还需要拿到原数据处理，。
	bool isInsertSort=false;
	for(int i = 1;i < src.size(); ++i){
		isInsertSort = perInsertSort(src,dest,i);
		if(isInsertSort){
			cout<<"Insertion Sort"<<endl;
			if(i + 1 <= src.size()){ // 需要继续排序
				perInsertSort(src,dest,i+1);
				print(src);
				cout<<endl;
				break;
			}else{ // 已经是最后一次排序，则直接输出结果。
                print(src);
                cout << endl;
			}
		}
	}
	if(!isInsertSort){
		int step = 1;
		while(step < temp.size()){
			if(temp==dest){
				cout<<"Merge Sort"<<endl;
				mergeSort(temp,step);
				print(temp);
				cout<<endl;
			    break;
			}
			mergeSort(temp,step);
			step *= 2;
		}
	}
	return 0;
}