P 1035 插入与归并

转跳点 ：🐏

 

1035 插入与归并 (25分)

 

根据维基百科的定义：

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

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

　　这道题比较有意思，需要用到归并排序和插入排序的知识，两种排序的博客我都写了，自行转跳。

这道题有两种解法，

　　　　第一种是写两个排序算法，每执行完一轮就比较一次，时间复杂度 T(O) = O(N^3+N^2logN)，太暴力了

　　　　第二种是利用插入排序的特性：插入排序，前面是排好序的，后面是与初始序列相同。只要符合这个条件的就是插入，不符合就是归并

用第一种方法暴力就行，但是第二种就需要对归并和插入排序十分熟悉，因为要写一个单步的归并和插入。插入的单步十分容易实现只要知道第几个没排好，继承索引，找到位置插入就行了。而归并就有些麻烦，需要完完整整的归并。

 

AC代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int Merge = 0;
void InsertSorted(int arr[], int mid[], int n);
void MergeSorted(int arr[], int mid[], int n);
int ArrayEqual(int arr[], int ary[], int n);
void ArrayPrint(int arr[], int n);

int main(void)
{
    static int n;
    int arr[101];
    int ary[101];
    int mid[101];

    scanf("%d", &n);

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

    for (int i = 0; i < n; i++)
    {
        scanf("%d", &mid[i]);
    }
    
    InsertSorted(arr, mid, n);
    if (Merge)
    {
        MergeSorted(ary, mid, n);
    }

    return 0;
}

//插入排序
void InsertSorted(int arr[], int mid[], int n)
{
    int j, temp;

    for (int i = 1; i < n; i++)
    {
        j = i;
        temp = arr[i];
        while (j > 0 && temp < arr[j - 1])
        {
            arr[j] = arr[j - 1];
            j--;
        }
        arr[j] = temp;

        if (ArrayEqual(arr, mid, n))
        {
            j = ++i;
            temp = arr[i];
            while (j > 0 && temp < arr[j - 1])
            {
                arr[j] = arr[j - 1];
                j--;
            }
            arr[j] = temp;
            printf("Insertion Sort\n");
            ArrayPrint(arr, n);
            Merge = 0;
            return;
        }
    }
    Merge = 1;
}

void MergeAdd(int arr[], int left, int mid, int right, int *tmp)
{
    int i = left;
    int j = mid + 1;
    int k = left;
    while (i <= mid && j <= right)
    {
        tmp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];
    }
    while (i <= mid)
    {
        tmp[k++] = arr[i++];
    }
    while (j <= right)
    {
        tmp[k++] = arr[j++];
    }
    //把tmp中的内容拷给arr数组中
    //进行归并的时候，处理的区间是arr[left,right),对应的会把
    //这部分区间的数组填到tmp[left,right)区间上
    memcpy(arr + left, tmp + left, sizeof(int) * (right - left + 1));
}

void MergeSort(int arr[], int len, int *tmp, int mid[], int n)
{
    if (len <= 1)
    {
        return;
    }
    int flag = 0;

    //定义一个步长gap，初始值为1，相当于每次只合并两个长度为1的元素
    for (int gap = 1; gap <= len; gap *= 2)
    {
        for (int i = 0; i <= len; i += 2 * gap)
        {
            int beg = i;
            int mid = (gap - 1) + i;
            if (mid >= len)
            {
                mid = len;
            }
            int end = mid + gap;
            if (end >= len)
            {
                end = len;
            }
            MergeAdd(arr, beg, mid, end, tmp);
        }
        if (flag)
        {
            printf("Merge Sort\n");
            ArrayPrint(arr, n);
            return;
        }
        if (ArrayEqual(arr, mid, n))
        {
            flag = 1;
        }
    }
}
//归并排序接口
void MergeSorted(int arr[], int mid[], int n)
{
    int *temp = malloc(sizeof(int) * n);
    MergeSort(arr, n - 1, temp, mid, n);
    free(temp);
}
//输出数组
void ArrayPrint(int arr[], int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("%d%s", arr[i], n - 1 == i ? "" : " ");
    }
}
//判断相等
int ArrayEqual(int arr[], int ary[], int n)
{
    for (int i = 0; i < n; i++)
    {
        if (arr[i] != ary[i])
        {
            return 0;
        }
    }
    return 1;
}

 

第二种：

#include <stdio.h>
#include <stdlib.h>

int isinsertion(int n, int num[], int mid[]);
int nextmerge(int n, int num[], int mid[]);
int cmp(const void *a, const void *b) { return (*(int *)a) > (*(int *)b); }

int main()
{
    int n, num[100], mid[100];
    int i;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        scanf("%d", &num[i]);
    }
    for (i = 0; i < n; i++)
    {
        scanf("%d", &mid[i]);
    }

    if (isinsertion(n, num, mid))
    {
        nextmerge(n, num, mid);
    }

    for (i = 0; i < n; i++)
    {
        printf("%d%s", num[i], i == n - 1 ? "" : " ");
    }
    return 0;
}

int isinsertion(int n, int num[], int mid[])
{
    int i, lenth;
    for (i = 0; i < n - 1 && mid[i] <= mid[i + 1]; i++)
    {//前面是排好序的
        continue;
    }
    for (i++, lenth = i; i < n && mid[i] == num[i]; i++)
    {//后面是与初始序列相同
        continue;
    }
    if (i < n)
    {
        return 1;
    }
    printf("Insertion Sort\n");
    lenth++;
    qsort(num, lenth, sizeof(int), cmp);
    return 0;
}

int nextmerge(int n, int num[], int mid[])
{
    int i, j, lenth;
    printf("Merge Sort\n");
    for (lenth = 1, i = 0; i < n && lenth <= n; lenth *= 2)
    { //只能一步步归并
        for (i = 0; i < n && num[i] == mid[i]; i++)
            ;
        for (j = 0; j < n / lenth; j++)
        {
            qsort(num + j * lenth, lenth, sizeof(int), cmp);
        }
        qsort(num + j * lenth, n % lenth, sizeof(int), cmp);
    }
    return 0;
}

　　偷懒了，用qsort”实现“归并

 

　　 PTA不易，诸君共勉！