PAT 乙级 1035 java

在提交的过程中一直提示格式错误，发现题目有一个坑，不让数组打印输出的时候首尾出现空格，所以卡了很久，所以在打印输出的时候进行了判断，题目的思路在代码里面。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;

/**
 * 题目思路：
 * 1.插入排序：判断前一部分是否有序以及后一部分是否与原数组相同，相同则在不同的位置在进行一次插入排序
 * 2.归并排序：先进行插入排序的判断，不是插入排序那么就是归并排序，在归并的过程中，每归并一次就进行判断是否与原数组相同
 *      在归并的过程中传入一个数组，用于获得下一次归并的结果
 *
 *   题目中要求的归并排序不是使用递归方式实现的，所以在比较中永远不会出现modi=dest的情况，此时，需要使用迭代来实现递归排序
 *
 *  */
public class p1035 {
    private static boolean flag_1=false;
    public static void main(String[] args) throws Exception{
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        int num=Integer.parseInt(br.readLine());
        String [] str_dest=br.readLine().split("[ ]");
        int []dest=new int[num];
        String [] str_modi=br.readLine().split("[ ]");
        int []modi=new int[num];
        for (int i = 0; i <num ; i++) {
            dest[i]=Integer.parseInt(str_dest[i]);
        }
        for (int i = 0; i <num ; i++) {
            modi[i]=Integer.parseInt(str_modi[i]);
        }

        //开始判断，modi数组是否为插入排序
        boolean result_flag=true;

        int i=0;
        for( ;i<num-1&&modi[i]<=modi[i+1];i++);
        //此时拿到对应有序的索引
        i++;
        for(;i<num;i++){
            if(dest[i]!=modi[i]){
                //有序序列的后面数列与原数组不同，此时不为插入排序
                result_flag=false;
                break;
            }
        }
        int[] result=new int[num];
        if(result_flag==false){//不为插入排序,进行归并操作

            IterMergeSort(dest,result,modi);

        }else{//为插入排序，进行插入排序
            iS(dest,result ,modi );
        }

    }
    public static int[] iS(int[] num,int[] result,int[] dest){
        for (int i = 0; i <num.length-1 ; i++) {
            int temp=num[i+1];
            int j=i+1;
            for (;j>0&&num[j-1]>temp;j--) {
                num[j]=num[j-1];
            }
            num[j]=temp;
            if(flag_1==true){
                System.arraycopy(num, 0, result,0 ,num.length );

                System.out.println("Insertion Sort");
                for (int k = 0; k <result.length ; k++) {
                    if(k==result.length-1){
                        System.out.print(result[k]);
                    }else{
                        System.out.print(result[k]+" ");
                    }
                }

                flag_1=false;
                return num;
            }
            if(Arrays.equals(dest,num )){
                flag_1=true;
            }
        }
        return num;
    }

    //result 用于存储下一次归并的数组，dest为判断数组，num为原数组
    public static void IterMergeSort(int[] num,int[] result,int[] dest){
        //开始对原数组进行迭代排序
            int k=1;
            boolean flag=false;
            while(flag==false){
                if(Arrays.equals(num,dest)){
                    flag=true;
                }
                k=k*2;
                for (int p=0;p<num.length/k;p++){
                    sort(num,p*k ,(p+1)*k-1);
                }
                //不够一组归并的内容，独立出来排序
                sort(num, num.length/k*k,num.length-1 );
                if(flag==true){
                    System.arraycopy(num,0 ,result,0 ,num.length );
                    System.out.println("Merge Sort");
                    for (int m = 0; m <result.length ; m++) {
                        if(m==result.length-1){
                            System.out.print(result[m]);
                        }else{
                            System.out.print(result[m]+" ");
                        }
                    }
                    return;
                }

            }

        }
        public static void sort(int[]a,int from,int to){
        for(int i=from;i<to;i++){
            for(int j=i+1;j<=to;j++){
                if(a[j]<a[i]){
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
            }
        }
        }
}

}