PAT (Basic Level) Practise （中文） 1035. 插入与归并(25)

1035. 插入与归并(25)

时间限制

200 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

作者

CHEN, Yue

根据维基百科的定义：

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

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

/*
 * 首先是对题目的理解
 * 第一行是数组长度n
 * 第二行是初始数组的状态
 * 第三行是初始数组再排序过程中的中间态
 * 输出是中间态再进行一次XX排序的结果
 *
 * 首先你要理解插入与归并排序算法执行的过程
 * 百度后看图片演示就能很好的理解
 * java实现代码分别如下
 *     插入排序
 *  http://blog.csdn.net/kimylrong/article/details/17121519
 *  归并排序
 *  http://blog.csdn.net/jianyuerensheng/article/details/51262984
 *  翻译c++代码参考文章
 *  http://www.cnblogs.com/luorende/p/6121906.html

 *  c++ sort函数格式 数组名+数组需要排序的第一个坐标，数组名+数组需要排序的最后一个坐标+1）

 java自己没做出来，翻译的c++代码也有问题，这里就贴两篇我搜索到的博客供大家参考，

如果有大神用java代码实现了麻烦留个博客地址让我学习一下，非常感谢

 */

博客原文

http://blog.csdn.net/wanmeiwushang/article/details/51615740

#include<iostream>
#include<algorithm>
#include<cstdlib>
using namespace std;
bool equal(int a[],int b[],int N){  //判断是否相等
    for(int k=0;k<N;k++)
        if(a[k]!=b[k])
            return false; 
    return true;
}
void merger(int a[],int b[],int N){ //edge为步长，1,2,4,8……
    int edge=1;
    for(;;edge*=2){             //步长每次乘以2
        bool istrue=true;
        istrue=equal(a,b,N);    //先判断是否相等，再进行归并，这样若为真的话，在后面判断则会多进行一次归并
        for(int j=0;j<N;j+=edge){//每edge个元素进行一次排序
            int temp=edge+j;    
            if(temp>N)          //若最后元素个数不足步长，则最大为N即可
                temp=N;
            sort(a+j,a+temp);
        }
        if(istrue){             //如果相等则输出，并跳出循环
            cout<<"Merge Sort"<<endl;
            break;
        }   
    }
}
int main(){
    int N;
    cin>>N;
    int A1[N+5],A2[N+5];
    for(int i=0;i<N;i++)
        cin>>A1[i];
    for(int i=0;i<N;i++)
        cin>>A2[i];
    int i,j;
    for( i=0; A2[i]<=A2[i+1] && i<N-1; i++ ) ;       // i作为有序序列最后一个元素下标退出循环  
        for( j=++i; A1[j]==A2[j] && j<N; j++  ) ;    // A1 A2从 第一个无序的元素开始 逐一比对  
    if( j==N ){                         // 前半部分有序而后半部分未改动可以确定是插入排序  
        cout<<"Insertion Sort"<<endl;  
        sort( A1, A1+i+1 );  
    } 
    else merger(A1,A2,N);
    for(int k=0;k<N;k++){   
        if(k!=0)
        cout<<" ";
        cout<<A1[k];
    }
    return 0;
}
博客原文
https://www.liuchuo.net/archives/503
分析：一开始第三个测试点一直不过，天真的我以为可以模拟一遍归并的过程然后在过程中判断下一步是什么。。
然而真正的归并算法它是一个递归过程。。也就是先排左边一半，把左边的完全排列成正确的顺序之后，
再排右边一半的。。而不是左右两边一起排列的。。后来改了自己的归并部分判断的代码就过了。。。｡◕‿◕｡

#include <algorithm>

using namespace std ;

int cmp ( int a , int b ) {

     return a < b ;

}

int main ( ) {

     int n ;

     cin >> n ;

     int * a = new int [ n ] ;

     int * b = new int [ n ] ;

     for ( int i = 0 ; i < n ; i ++ ) {

         cin >> a [ i ] ;

     }

     for ( int i = 0 ; i < n ; i ++ ) {

         cin >> b [ i ] ;

     }

     int i , j ;

     for ( i = 0 ; i < n - 1 && b [ i ] <= b [ i + 1 ] ; i ++ ) ;

     for ( j = i + 1 ; a [ j ] == b [ j ] && j < n ; j ++ ) ;

     if ( j == n ) {

         cout << "Insertion Sort" << endl ;

         sort ( a , a + i + 2 , cmp ) ;

     } else {

         cout << "Merge Sort" << endl ;

         int k = 1 ;

         int flag = 1 ;

         while ( flag ) {

             flag = 0 ;

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

                 if ( a [ i ] != b [ i ] )

                     flag = 1 ;

             }

             k = k * 2 ;

             for ( i = 0 ; i < n / k ; i ++ )

                 sort ( a + i * k , a + ( i + 1 ) * k , cmp ) ;

             sort ( a + n / k * k , a + n , cmp ) ;

         }

     }

    

     for ( j = 0 ; j < n - 1 ; j ++ ) {

         cout << a [ j ] << " " ;

     }

     cout << a [ n - 1 ] ;

     delete [ ] a ;

     delete [ ] b ;

     return 0 ;

}