PTA Insert or Merge

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 NN (\le 100≤100). Then in the next line, NN integers are given as the initial sequence. The last line contains the partially sorted sequence of the NN 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 resuling 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

解答

这题目就是先用插入排序去尝试，每插入一次就比较与题目中的数组是否相等，如果相等的话就再进行一次插入然后输出（用flag变量来控制，相等就置为true，每一次插入后检查flag为true就跳出循环），如果全部排序完成还没有相等的，就说明是归并排序，这里隐含条件是用迭代的归并排序，同样每一次都与题中数组比较，相等后就再归并一次。

//
//  main.c
//  Insert or Merge
//
//  Created by 余南龙 on 2016/12/9.
//  Copyright © 2016年 余南龙. All rights reserved.
//

#include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
#define MAX 101

int comp(const void *a, const void *b){
    return *(int*)a - *(int*)b;
}

void Init(int initial[], int tmp[], int partial[], int *N){
    int i, tmp_val;

    scanf("%d", N);
    tmp_val = *N;
    ; i < tmp_val; i++){
        scanf("%d", initial + i);
        tmp[i] = initial[i];
    }
    ; i < tmp_val; i++){
        scanf("%d", partial + i);
    }
}

void Output(int a[], int size){
    int i;

    ; i < size; i++) {
         == i) {
            printf("%d", a[i]);
        }
        else{
            printf(" %d", a[i]);
        }
    }
}

int Is_Equal(int a[], int b[], int size){
    int i;

    ; i < size; i++){
        if(a[i] != b[i]){
            return false;
        }
    }
    return true;
}

int Is_Insertion_Sort(int initial[], int partial[], int size){
    ;

    ; i < size; i++){
        tmp = initial[i];
        ; j >= ; j--){
            if(initial[j] > tmp){
                initial[j + ] = initial[j];
            }
            else{
                break;
            }
        }
        initial[j + ] = tmp;
         == flag){
            return true;
        }
        if(Is_Equal(initial, partial, size)){
            flag = ;
        }
    }

    return false;
}

void New_Merge_Sort(int initial[], int partial[], int size){
    int i, j, flag = false;

    ; i < size; i *= ){
        ; j < size; j += i * ){
             < size)
                qsort(initial + j, i * , sizeof(int), comp);
            else if(size - j > i){
                qsort(initial + j, size - j, sizeof(int), comp);
            }
        }
        if(flag){
            break;
        }
        if(Is_Equal(initial, partial, size)){
            flag = true;
        }
    }
}

int main(){
    int N;
    int initial[MAX], partial[MAX], tmp[MAX];

    Init(initial, tmp, partial, &N);
    if(!Is_Insertion_Sort(initial, partial, N)){
        New_Merge_Sort(tmp, partial, N);
        printf("Merge Sort\n");
        Output(tmp, N);
    }
    else{
        printf("Insertion Sort\n");
        Output(initial, N);
    }
}