Insert or Merge

本博客的代码的思想和图片参考：好大学慕课浙江大学陈越老师、何钦铭老师的《数据结构》

 

Insert or Merge

1 Question

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 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
1 2 3 8 4 5 7 9 0 6

• 时间限制：400ms

• 内存限制：64MB

• 代码长度限制：16kB

• 判题程序：系统默认

• 作者：陈越

• 单位：浙江大学

2 Solution

2.1 How to Different Merge or Insertion

We know, In merge sort,the sequence will be ordered partially,but insertion has a point. Before this point,the sequence is ordered,after this point,the sequence is same as the original sequence. The insertion sort is more easily to judge. So we use insertion method to judge which method it has used. If it is use insertion sort,we will return the index which is the next insertion point,then do the next insertion sort. Otherwise we will return zero to indicate this used the merge sort.

The code is followed:

/*

* Judge which sorting method the system has used.If it is the insertion merge,return the index

* of the next insert point.Otherwise return zero

* @param source A <code>elementType</code> array to store the original data

* @parampartical A <code>elementType</code> array to store elements which has been sorted partial

* @param n The length of the array

*/

intjudgeMergeOrInsertion(elementType source[], elementType partial[], int n) {

int i;

int min = partial[0];

int insertPoint;

for (i = 1; i < n; i++) {

insertPoint = i;

if (partial[i] > min) {

min = partial[i];

} else {

break;

}

}

for (; i < n; i++) {

if (partial[i] != source[i]) {

return 0;

}

}

return insertPoint;

}

2.2 How to Determine the Merge Sort Length

Algorithms thoughts:

we know the sequence length is 2 4 8 16,so we can let length from 2 4 8 ... n

1.We judge the length whether more than 2, we check the number whether ordered between two sub-sequence. If all two sub-sequence is ordered,we will check the length whether more than four. Otherwise the length is equal two and return it.

2.we let length increase no more than n ,we can get length and return it.

We can use a picture to show this algorithms thoughts:

 

 

 

 

 

 

 

 

代码如下：

/*

* Find the length of merge sort sub-sequence.

* Algorithms thoughts:

* we know the sequence length is 2 4 8 16,so we can let length from 2 4 8 ... n

* 1.We judge the length whether more than 2, we check the number whether ordered between two sub-sequence. If all two sub-sequence is ordered,we will check the length whether more than four. Otherwise the length is equal two and return it.

* 2.we let length increase no more than n ,we can get length and return it.

*

* @param partial A <code>elementType</code> array to store elements which has been sorted partial

* @param n The length of the array

* @return The length of the sub-sequence

*/

intfindMergeSubSequenceLength(intpartial[],intn){

intlength,i;

for(length=2;length<=n;length*=2){

for(i=1;i<n/length;i+=2){

if(partial[i*length-1]>partial[i*length]){

returnlength;

}

}

}

returnn;

}

 

完整的代码如下：

/*
 * mergeOrInsert.c
 *
 *  Created on: 2017年5月19日
 *      Author: ygh
 */
#include <stdio.h>
#include <stdlib.h>
#define MAX_LENGTH 100
#define MAX_VALUE 65535
typedef int elementType;

/*
 *Get the input data from the command line
 *@param source A <code>elementType</code> array to store the original data
 *@param partical A <code>elementType</code> array to store elements which has been sorted partial
 *@param n The length of the array
 */
void getInputData(elementType source[], elementType partial[], int n) {
    int i;
    elementType x;
    for (i = 0; i < n; i++) {
        scanf("%d", &x);
        source[i] = x;
    }

    for (i = 0; i < n; i++) {
        scanf("%d", &x);
        partial[i] = x;
    }
}

/*
 * Print the array to console
 * @param a A integer array need to sort
 * @param n The length of the array
 */
void printArray(elementType a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        if (i == n - 1) {
            printf("%d", a[i]);
        } else {
            printf("%d ", a[i]);
        }
    }
    printf("\n");
}

/*
 * Judge which sorting method the system has used.If it is the insertion merge,return the index
 * of the next insert point.Otherwise return zero
 * @param source A <code>elementType</code> array to store the original data
 * @param partical A <code>elementType</code> array to store elements which has been sorted partial
 * @param n The length of the array
 */
int judgeMergeOrInsertion(elementType source[], elementType partial[], int n) {
    int i;
    int min = partial[0];
    int insertPoint;
    for (i = 1; i < n; i++) {
        insertPoint = i;
        if (partial[i] > min) {
            min = partial[i];
        } else {
            break;
        }
    }
    for (; i < n; i++) {
        if (partial[i] != source[i]) {
            return 0;
        }
    }
    return insertPoint;
}

/*
 * Execute one time insertion sort from insertPoint
 * @param partial A <code>elementType</code> array to store elements which has been sorted partial
 * @param inserPoint The index of next point
 */
void insertion_sort_pass(elementType partial[], int inserPoint) {
    int i;
    int x = partial[inserPoint];
    for (i = inserPoint; i > 0; i--) {
        if (x < partial[i - 1]) {
            partial[i] = partial[i - 1];
        } else {
            break;
        }
    }
    partial[i] = x;
}

/*
 * Find the length of merge sort sub-sequence.
 * Algorithms thoughts:
 * we know the sequence length is 2 4 8 16,so we can let length from 2 4 8 ... n
 * 1.We judge the length whether more than 2, we check the number whether ordered between two sub-sequence. If all two sub-sequence is ordered,we will check the length whether more than four. Otherwise the length is equal two and return it.
 * 2.we let length increase no more than n ,we can get length and return it.
 *
 * @param partial A <code>elementType</code> array to store elements which has been sorted partial
 * @param n The length of the array
 * @return The length of the sub-sequence
 */
int findMergeSubSequenceLength(int partial[], int n) {
    int length, i;
    for (length = 2; length <= n; length *= 2) {
        for (i = 1; i < n / length; i += 2) {
            if (partial[i * length - 1] > partial[i * length]) {
                return length;
            }
        }
    }
    return n;
}

/*
 * Merge sub-sequence to original array.
 * @param a original <code>elementType</code> array to store the elements
 * @param tmpA temporary  <code>elementType</code> array to store the temporary elements
 * @param l The start index of left sub-sequence
 * @param r The start index of left sub-sequence
 * @param rightEnd The end index of left sub-sequence
 */
void merge(elementType a[], elementType tmpA[], int l, int r, int rightEnd) {
    /*
     * lefeEnd is the r-1,the sub-sequence is adjacent
     */
    int leftEnd = r - 1;
    /*
     * tmp is the counter of the <code>tmpA</code>
     * we should let <code>tmpA</code> index corresponding original array
     */
    int tmp = l;
    /*
     * Record the quantity of the all elements
     */
    int numElements = rightEnd - l + 1;
    int i;
    while (l <= leftEnd && r <= rightEnd) {
        if (a[l] <= a[r]) {
            tmpA[tmp++] = a[l++];
        } else {
            tmpA[tmp++] = a[r++];
        }
    }
    while (l <= leftEnd) {
        tmpA[tmp++] = a[l++];
    }
    while (r <= rightEnd) {
        tmpA[tmp++] = a[r++];
    }

    /*
     * Put <code>tmpA</code> elements into the original array
     */
    for (i = 0; i < numElements; i++, rightEnd--) {
        a[rightEnd] = tmpA[rightEnd];
    }
}

/*
 *merge ordered sub-sequence
 * @param a original <code>elementType</code> array to store the elements
 * @param tmpA temporary  <code>elementType</code> array to store the temporary elements
 * @param n The length of the a
 * @param the ordered current sub-sequence length
 */
void mergerPass(elementType a[], elementType tmpA[], int n, int lenth) {
    int i, j;
    /*
     * The loop will stop when meet the last two ordered sub-sequence
     * The rest may be two sub-sequence of one sub-sequence
     */
    for (i = 0; i <= n - 2 * lenth; i += lenth * 2) {
        merge(a, tmpA, i, i + lenth, i + 2 * lenth - 1);
    }
    /*
     *If the rest of is two sub-sequence
     */
    if (i + lenth < n) {
        merge(a, tmpA, i, i + lenth, n - 1);
    } else {
        for (j = i; j < n; j++)
            tmpA[j] = a[j];
    }
}

int main() {
    elementType source[MAX_LENGTH];
    elementType partial[MAX_LENGTH];
    int n;
    int length = 0;
    elementType *tmpA;
    scanf("%d", &n);
    getInputData(source, partial, n);
    int inserPoint = judgeMergeOrInsertion(source, partial, n);
    if (inserPoint != 0) {
        if (inserPoint < n) {
            insertion_sort_pass(partial, inserPoint);
        }
        printf("Insertion Sort\n");
    } else {
        tmpA = malloc(n * sizeof(elementType));
        length = findMergeSubSequenceLength(partial, n);
        mergerPass(partial, tmpA, n, length);
        printf("Merge Sort\n");
    }
    printArray(partial, n);
    return 0;
}

但是还有一个点无法通过，如果有大神知道，可以在下面评论告诉我