两个或多个有序数组合并为一个有序数组

要求：
不使用for循环
不使用API方法进行数据迁移 ：
System.arraycopy(int[] a,…);
Arrays.copyOf(int[] a,…);

一、两个有序数组合并为一个有序数组

方案1

import java.util.Arrays;

public class ArraySortTest {
    public static void main(String[] args) {
        //方法1，普通for循环+工具类Arrays.sort(arraySort)
        
        //给定2个有序数组，合并成一个有序数组
        int[] a = {2,5,7,8,17};
        int[] b = {1,3,6,9,13,18};
        //创建合并之后的数组
        int[] arraySort = new int[a.length+a.length];
        //先将a放入array
        for (int i = 0; i < a.length; i++) {
            arraySort[i] = a[i];
        }
        //再将b放入array
        for (int j = 0; j < b.length; j++) {
            arraySort[a.length+j-1] = b[j];
        }
        //最后对array进行排序
        Arrays.sort(arraySort);
        for (int i : arraySort ) {
            System.out.print(i+"，");
        } 
    }
}

方案2

import java.util.Arrays;

public class ArraySortTest {
    public static void main(String[] args) {
        //方法2
        int[] a = {2,5,7,8,17};
        int[] b = {1,3,6,9,13,18};
        
        //定义三个起始变量，分别对应数组a、b、arraySort的下标初始值
        int i= 0;
        int j= 0;
        int x= 0;
        int[] arraySort = new int[a.length+b.length];
        //将小的先放入arraySort 
        while(i < a.length && j < b.length){
            if(a[i] < b[j]){
                arraySort[x] = a[i];
                x++;
                i++;
            }else{
                arraySort[x] = b[j];
                j++;
                x++;
            }
        }

        //a先迁移完毕，剩下的b直接迁移就好了
        if(i >= a.length){
            while (j < b.length){
                arraySort[x] = b[j];
                j++;
                x++;
            }
        }

        //b先迁移完毕，剩下的a直接迁移就好了
        if(j >= b.length){
            while (i < a.length){
                arraySort[x] = a[i];
                i++;
                x++;
            }
        }

        //打印数组array
        for (int ast : arraySort ) {
            System.out.print(ast+"，");
        }

    }
}

执行结果

二、多个有序数组合并为一个有序数组

方案1

import java.util.Arrays;

public class MoreArraySortTest {
    public static void main(String[] args) {
        int[] arr1 = {1,3,5,6,11};
        int[] arr2 = {1,2,7,12};
        int[] arr3 = {4,6,19,11};
        int[] arr4 = {8,89};
        
        //两两合并排序，最后再对前面的排序进行合并
        int[] merge1 = merge(arr1,arr2);
        int[] merge2 = merge(arr3,arr4);

        int[] merge = merge(merge1, merge2);

        System.out.println(Arrays.toString(merge));
    }

    public static int[] merge(int[] a, int[] b){
        //定义三个起始变量，分别对应数组a、b、arraySort的下标初始值
        int i= 0;
        int j= 0;
        int x= 0;
        int[] arraySort = new int[a.length+b.length];

        while(i < a.length && j < b.length){
            if(a[i] < b[j]){
                arraySort[x] = a[i];
                x++;
                i++;
            }else{
                arraySort[x] = b[j];
                j++;
                x++;
            }
        }

        //a先迁移完毕，剩下的b直接迁移就好了
        if(i >= a.length){
            while (j < b.length){
                arraySort[x] = b[j];
                j++;
                x++;
            }
        }

        //b先迁移完毕，剩下的a直接迁移就好了
        if(j >= b.length){
            while (i < a.length){
                arraySort[x] = a[i];
                i++;
                x++;
            }
        }

        return arraySort;
    }
}

执行结果

方案2

public class KSortedArray {
    public static void main(String[] args){
        int[] a = {1,3,5,7,9};
        int[] b = {2,5,7,17,110};
        int[] c = {0,1,6,8,9,11};
        int[] d = {0,4,7,22};
        int[] result = sort(a,b,c,d);
        for (int r:result) {
            System.out.print(r+",");
        }
    }

    /**
     * 多数组排序整合
     * @param data
     * @return
     */
    private static int[] sort(int[]...data) {
        if(data == null)return null;
        int[] result = data[0];
        if(data.length == 1)return result;
        for (int i=1 ; i<data.length ; i++) {
            result = sort(result,data[i]);
        }
        return result;
    }

    /**
     * 两个已排序数组合并处理
     * @param a
     * @param b
     * @return
     */
    private static int[] sort(int[] a,int[] b){
        // 结果返回数组
        int result[] = new int[a.length+b.length];
        // 结果返回数组下标
        int resultCount = -1;
        // 最值小的数组循环标记
        int minCount = 0;
        int[] maxValue = a[a.length-1] >= b[b.length-1] ? a : b;
        int[] minValue = a[a.length-1] < b[b.length-1] ? a : b;
        for(int i = 0 ; i < maxValue.length ; i++){
            resultCount++;
            if(minCount < minValue.length){
                // 因为数组是排序的，所以已比较的数据minValue[minCount]不会重复比较
                if(maxValue[i] >= minValue[minCount]){
                    result[resultCount] = minValue[minCount];
                    i--;
                    minCount++;
                }else{
                    // 大数组拥有最小值，minCount需要再次比较，所以不需要+1
                    result[resultCount] = maxValue[i];
                }
            }else{
                // 已不存在小数组比较，此时大数组获取最小值
                result[resultCount] = maxValue[i];
            }
        }
        return result;
    }
}

执行结果