1035. 插入与归并

根据维基百科的定义：

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

归并排序进行如下迭代操作：首先将原始序列看成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

算法：

1. 算法开始。
2. 写出运用插入算法的排序函数。每读入一个数字就把它放在适当的位置，该位置上原来的数字以及该位置之后的数字都向后移动一位。
3. 写出运用迭代归并算法的排序函数。首先设置i=2，将数列分为大小为2的子串，对每个子串排序。然后i乘以2，对数列进行分割，然后对每个子串进行排序。如果有多余的元素但达不到i个，将其当做一个子串，进行排序。以此循环一直到i大于等于数列长度。然后对整个数列进行排序。分别设置变量j、k标记构成新子串的两个旧子串的位置，进行比较，将较小的元素复制到新字符串，然后经过复制的元素的位置加一，一直到两个旧子串排序完毕。
4. 读入数据。
5. 每排序一轮就把新数列与目标数列进行比较，相等就再用该排序算法排序一轮，然后输出该算法名称和数列。
6. 算法结束。

第二个测试点死也通不过……先放着，以后再改。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void insertion_sort(int* array, int i);
void merge_sort(int* array, int n, int i);
void merge(int* array, int* tmp, int left, int center, int right);
int cmp(int* array1, int* array2, int n);
void print(int* array, int n);
int main(int argc, const char * argv[]) {
    int n, i;
    int *array1, *array2, *tmp;
    scanf("%d", &n);
    array1=(int*)calloc(n, sizeof(int));
    array2=(int*)calloc(n, sizeof(int));
    tmp=(int*)calloc(n, sizeof(int));
    for(i=0; i<n; i++){
        scanf("%d", array1+i);
    }
    for(i=0; i<n; i++){
        scanf("%d", array2+i);
    }
    memcpy(tmp, array1, sizeof(int)*n);
    i=1;
    while((!cmp(tmp, array2, n))&&(i<n)){
        insertion_sort(tmp, i);
        i++;
    }
    if(i<n){
        puts("Insertion Sort");
        insertion_sort(tmp, i);
        print(tmp, n);
    }
    else{
        i=1;
        memcpy(tmp, array1, sizeof(int)*n);
        while(!cmp(array2, tmp, n)){
            merge_sort(tmp, n, i);
            i*=2;
        }
        puts("Merge Sort");
        merge_sort(tmp, n, i);
        print(tmp, n);
    }
    free(array1);
    free(array2);
    free(tmp);
    return 0;
}
void insertion_sort(int* array, int i){
    int j;
    int tmp;
    tmp=array[i];
    for(j=i; (j>0)&&(array[j-1]>tmp); j--){
        array[j]=array[j-1];
    }
    array[j]=tmp;
    return ;
}
void merge_sort(int* array, int n, int i){
    int left, center, right;
    int* tmp=(int*)calloc(n, sizeof(int));
    for(left=0; left+i<n; left+=2*i){
        center=left+i;
        right=center+i>n?n:center+i;
        merge(array, tmp, left, center, right);
    }
    memcpy(array, tmp, sizeof(int)*(left<n?left:n));
    free(tmp);
}
void merge(int* array, int* tmp, int left, int center, int right){
    int i, j, k;
    for(i=left, j=center, k=left; i<center&&j<right;){
        if(array[i]<array[j]){
            tmp[k++]=array[i++];
        }
        else{
            tmp[k++]=array[j++];
        }
    }
    while(i<center){
        tmp[k++]=array[i++];
    }
    while(j<right){
        tmp[k++]=array[j++];
    }
}
int cmp(int* array1, int* array2, int n) {
    int i;
    for(i=0; i<n; i++){
        if(array1[i]!=array2[i]){
            return 0;
        }
    }
    return 1;
}
void print(int* array, int n){
    int i;
    for(i=0; i<n-1;i++){
        printf("%d ", array[i]);
    }
    printf("%d", array[i]);
    return ;
}

更新于2016/3/5。编写于VS2015上的代码。修改scanf_s函数就可以在PAT上AC。

#include <stdio.h>
#include <stdlib.h>
int InsertionSort(int* temp, int* medium, int n);
void MergeSort(int* temp, int* medium, int n);
int main(void) {
	int n, *origin, *medium, *temp, i;
	scanf_s("%d", &n);
	origin = (int*)calloc(n, sizeof(int));
	medium = (int*)calloc(n, sizeof(int));
	temp = (int*)calloc(n, sizeof(int));
	for (i = 0; i < n; i++) {
		scanf_s("%d", origin + i);
	}
	for (i = 0; i < n; i++) {
		scanf_s("%d", medium + i);
	}
	for (i = 0; i < n; i++) {
		temp[i] = origin[i];
	}
	if (InsertionSort(temp, medium, n)) {
		puts("Insertion Sort");
		printf("%d", temp[0]);
		for (i = 1; i < n; i++) {
			printf(" %d", temp[i]);
		}
	}
	else {
		for (i = 0; i < n; i++) {
			temp[i] = origin[i];
		}
		MergeSort(temp, medium, n);
		puts("Merge Sort");
		printf("%d", temp[0]);
		for (i = 1; i < n; i++) {
			printf(" %d", temp[i]);
		}
	}
	free(origin);
	free(medium);
	free(temp);
	return 0;
}
int InsertionSort(int* temp, int* medium, int n) {
	int i, j, l, flag = 0;
	for (i = 1; i < n; i++) {
		l = temp[i];
		for (j = i - 1; j >= 0; j--) {
			if (temp[j] > l) {
				temp[j + 1] = temp[j];
			}
			else {
				break;
			}
		}
		temp[j + 1] = l;
		for (j = 0; j < n && !flag; j++) {
			if (medium[j] != temp[j]) {
				break;
			}
		}
		if (j == n) {
			flag = 1;
			continue;
		}
		if (flag) {
			return 1;
		}
	}
	return 0;
}
void MergeSort(int* temp, int* medium, int n) {
	int left, middle, right, step = 1, i, j, k, flag = 0;
	int *intermedium = (int*)calloc(n, sizeof(int));
	for (; step < n; step *= 2) {
		for (left = 0, middle = step, right = ((middle + step > n) ? n : (middle + step)); middle < n;) {
			for (i = 0, j = 0, k = 0; i < step && middle + j < right;) {
				if (temp[left + i] > temp[middle + j]) {
					intermedium[k++] = temp[middle + j++];
				}
				else {
					intermedium[k++] = temp[left + i++];
				}
			}
			while (i < step) {
				intermedium[k++] = temp[left + i++];
			}
			while (middle + j < right) {
				intermedium[k++] = temp[middle + j++];
			}
			while (--k >= 0) {
				temp[left + k] = intermedium[k];
			}
			left = right;
			middle = left + step;
			right = middle + step > n ? n : middle + step;
		}
		for (i = 0; i < n && !flag; i++) {
			if (medium[i] != temp[i]) {
				break;
			}
		}
		if (i == n) {
			flag = 1;
			continue;
		}
		if (flag) {
			free(intermedium);
			return ;
		}
	}
	free(intermedium);
	return ;
}