1035 插入与归并

根据维基百科的定义：
插入排序是迭代算法，逐一获得输入数据，逐步产生有序的输出序列。每步迭代中，算法从输入序列中取出一元素，将之插入有序序列中正确的位置。如此迭代直到全部元素有序。
归并排序进行如下迭代操作：首先将原始序列看成 N 个只包含 1 个元素的有序子序列，然后每次迭代归并两个相邻的有序子序列，直到最后只剩下 1 个有序的序列。
现给定原始序列和由某排序算法产生的中间序列，请你判断该算法究竟是哪种排序算法？

输入格式：

输入在第一行给出正整数 $N(\le 10^0)$；随后一行给出原始序列的 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

---

#include <iostream>
using namespace std;
#define MAXNUM 100
typedef int ElementType;

void InsertSort(ElementType A[],int P);	//插入排序

void Merge(ElementType A[], ElementType TmpA[], int L, int R, int RightEnd);	//归并
void Merge_pass(ElementType A[], ElementType TmpA[], int N, int length);
void MergeSort(ElementType A[], int N,int length);		//归并排序，循环实现

bool JudgeEqual(ElementType A[], ElementType B[],int N);

ElementType A1[MAXNUM];
ElementType A2[MAXNUM];
ElementType B[MAXNUM];

int main()
{
	int N;
	cin >> N;
	for (int i = 0; i < N; i++) {
		cin >> A1[i];
		A2[i] = A1[i];
	}
	for (int i = 0; i < N; i++)
		cin >> B[i];


	for (int i = 1, length = 1; i < N; i++, length *= 2) {

		InsertSort(A1, i);
		if (JudgeEqual(A1, B, N)) {
			cout << "Insertion Sort" << endl;
			InsertSort(B, i + 1);

			cout << B[0];
			for (int i = 1; i < N; i++)
				cout << " " << B[i];
			break;
		}

		if (length < N) {
			MergeSort(A2, N, length);
			if (JudgeEqual(A2, B, N)) {
				cout << "Merge Sort" << endl;
				MergeSort(B, N, length * 2);

				cout << B[0];
				for (int i = 1; i < N; i++)
					cout << " " << B[i];
				break;
			}
		}
	}
}

void InsertSort(ElementType A[],int P)
{
	int i;
	ElementType Tmp;

	Tmp = A[P];
	for (i = P; i > 0 && A[i - 1] > Tmp; i--)
		A[i] = A[i - 1];
	A[i] = Tmp;

}

void Merge(ElementType A[], ElementType TmpA[], int L, int R, int RightEnd)
{ /* 将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列 */
	int LeftEnd, NumElements, Tmp;
	int i;

	LeftEnd = R - 1; /* 左边终点位置 */
	Tmp = L;         /* 有序序列的起始位置 */
	NumElements = RightEnd - L + 1;

	while (L <= LeftEnd && R <= RightEnd) {
		if (A[L] <= A[R])
			TmpA[Tmp++] = A[L++]; /* 将左边元素复制到TmpA */
		else
			TmpA[Tmp++] = A[R++]; /* 将右边元素复制到TmpA */
	}

	while (L <= LeftEnd)
		TmpA[Tmp++] = A[L++]; /* 直接复制左边剩下的 */
	while (R <= RightEnd)
		TmpA[Tmp++] = A[R++]; /* 直接复制右边剩下的 */

	for (i = 0; i < NumElements; i++, RightEnd--)
		A[RightEnd] = TmpA[RightEnd]; /* 将有序的TmpA[]复制回A[] */
}

void Merge_pass(ElementType A[], ElementType TmpA[], int N, int length)
{ /* 两两归并相邻有序子列 */
	int i;

	for (i = 0; i <= N - 2 * length; i += 2 * length)
		Merge(A, TmpA, i, i + length, i + 2 * length - 1);

	if (i + length < N) /* 归并最后2个子列*/
		Merge(A, TmpA, i, i + length, N - 1);

	else /* 最后只剩1个子列*/
		for (int j = i; j < N; j++)
			TmpA[j] = A[j];
}

void MergeSort(ElementType A[], int N, int length)
{
	//循环实现

	ElementType *TmpA;

	TmpA = (ElementType *)malloc(N * sizeof(ElementType));
	if (TmpA != NULL) {

		Merge_pass(A, TmpA, N, length);

		free(TmpA);
	}
	else printf("空间不足");
}

bool JudgeEqual(ElementType A[], ElementType B[], int N)
{
	bool flag = true;
	for (int i = 0; i < N; i++) {
		if (A[i] != B[i]) {
			flag = false;
			break;
		}
	}
	return flag;
}