Java 合并3个排序数组 公共类数组12{ 静态无效合并_排序（int A[]，int start，int end）{ 如果（结束-开始>1）{ int MIDLE1=（2*开始+结束+1）/3-1； int MIDLE2=2*MIDLE1-开始+1； 合并排序（A、开始、中间1）； 合并排序（A，中间1+1，中间2）； 合并排序（A，中间2+1，结束）； 合并（A、开始、中间1、中间2、结束）； } } 静态无效合并（int[]x，int开始，int中间1，int中间2，int结束）{ int n1=中间1-开始+1； int n2=中间2-中间1； int n3=结束-中间2； int left[]=new int[n1]；//定义并初始化三个数组。 int mid[]=新int[n2]； 右整数[]=新整数[n3]； for（int i=0；i

我没有遵循您的合并代码。它似乎太复杂了

下面是一种合并无限多个排序数组的方法，每个数组的大小不同

public class array12 {
    static void merge_sort(int A[], int start, int end) {
        if (end - start > 1) {
            int middle1 = (2 * start + end + 1) / 3 - 1;
            int middle2 = 2 * middle1 - start + 1;

            merge_sort(A, start, middle1); 

            merge_sort(A, middle1 + 1, middle2);

            merge_sort(A, middle2 + 1, end);

            merge(A, start, middle1, middle2, end);
        }
    }

    static void merge(int[] x, int start, int middle1, int middle2, int end) {
        int n1 = middle1 - start + 1;

        int n2 = middle2 - middle1;

        int n3 = end - middle2;

        int left[] = new int[n1];  // defining and initialising three arrays .

        int mid[] = new int[n2];

        int right[] = new int[n3];

        for (int i = 0; i < left.length; i++) {
            left[i] = x[i + start];
        }

        for (int i = 0; i < mid.length; i++) {
            mid[i] = x[i + middle1 + 1];
        }

        for (int i = 0; i < right.length; i++) {
            right[i] = x[i + middle2 + 1];
        }

        int i = 0;
        int j = 0;
        int k = 0;
        int c = start;


        // finding minimum element from the three arrays .

            while (i < n1 && j < n2 && k < n3) {
            if (left[i] <= mid[j] && left[i] <= right[k]) {
                x[c] = left[i];
                i++;
                c++;
            } else if (mid[j] <= left[i] && mid[j] <= right[k]) {
                x[c] = mid[j];
                j++;
                c++;
            } else {
                x[c] = right[k];
                k++;
                c++;
            }
        }

        // now only two arrays are left to be compared

        while (i < n1 && j < n2) {
            if (left[i] <= mid[j]) {
                x[c] = left[i];
                i++;
                c++;
            } else {
                x[c] = mid[j];
                j++;
                c++;
            }
        }

        while (j < n2 && k < n3) {
            if (mid[j] <= right[k]) {
                x[c] = mid[j];
                j++;
                c++;
            } else {
                x[c] = right[k];
                k++;
                c++;
            }
        }

        while (i < n1 && k < n3) {
            if (left[i] <= right[k]) {
                x[c] = left[i];
                i++;
                c++;
            } else {
                x[c] = right[k];
                k++;
                c++;
            }
        }

        // now only single array is left out of left[] , mid[] and right[].
        while (i < n1) {
            x[c] = left[i];
            i++;
            c++;
        }

        while (j < n2) {
            x[c] = mid[j];
            j++;
            c++;
        }

        while (k < n3) {
            x[c] = right[k];
            k++;
            c++;
        }

        System.out.println("");

        // printing array elements after every merge operation .

        for (int e = 0; e < x.length; e++) {
            System.out.print(x[e] + "  ");
        }
    }

    public static void main(String[] args) {

        int[] x = new int[9];

        for (int i = 0; i < x.length; i++) {
            x[i] = x.length - i;
        }
        System.out.println("initial array is : ");
        for (int i = 0; i < x.length; i++) {
            System.out.print(x[i] + "  ");
        }

        System.out.println("");
        merge_sort(x, 0, x.length - 1);

        System.out.println("");
        System.out.println("");
        System.out.println(" sorted array is : ");

        for (int i = 0; i < x.length; i++) {
            System.out.print(x[i] + "  ");
        }
    }
}

输出

[1,2,3,5,6,7,9,10,12,13,17,20,21,24]

如果使用类“Integer”而不是基元int不是一个问题，您可以使用它，基本上先进行合并，然后对它们进行排序：您可以调用数组。即使在相同的方法中进行排序，如果需要，也可以调用mergeAndSort

int[] a = { 3, 5, 9, 13, 17, 21 };
int[] b = { 2, 10, 20 };
int[] c = { 1, 7, 12, 24 };
int[] d = { 6 };
int[] merged = mergeSortedArrays(a, b, c, d);
System.out.println(Arrays.toString(merged));

---

这里有一个类似于的答案，但简化了（仍然使用Java 8）：

输出：

[1,2,3,5,6,7,9,10,12,13,17,20,21,24]

---

合并条件是什么？你是什么意思？我的意思是，你想如何合并，因为你的代码很长，需要一个小时才能理解你的代码。你应该打印

开始

，

结束

，

中间1

和

中间2

的值。确保它们看起来合理。你可以使用ArrayList或其他中间版本可能会帮助你解决所有这些讨厌的索引数学问题。但是，是的。我认为你没有传达实际的要求。你的min=INT.MAX不应该是0而不是0，因为否则怎么检查min>arrays[j][idx[j]]通过？只是curious@zenwraight

minJ==-1

意味着

min

的初始值无关紧要。问题中的代码要点是实现合并排序。用内置排序替换逻辑的合并部分肯定不是正确的答案。如果要使用内置排序，则要替换整个合并排序逻辑，而不仅仅是其中的合并部分，您可以通过将原始的

merge\u排序（x，0，x.length-1）

调用替换为而不是使用流来完成。

int[] a = { 3, 5, 9, 13, 17, 21 };
int[] b = { 2, 10, 20 };
int[] c = { 1, 7, 12, 24 };
int[] d = { 6 };
int[] merged = mergeSortedArrays(a, b, c, d);
System.out.println(Arrays.toString(merged));

import java.util.Arrays;

public class Main {
    public static Integer[] merge(Integer[]... arrays) {

        int count = 0;
        for (Integer[] array : arrays) {
            count += array.length;
        }

        Integer[] mergedArray = (Integer[]) java.lang.reflect.Array.newInstance(arrays[0][0].getClass(), count);
        int start = 0;
        for (Integer[] array : arrays) {
            System.arraycopy(array, 0, mergedArray, start, array.length);
            start += array.length;
        }
        return mergedArray;
    }

    public static void main(String[] args) {
        Integer[] array1 = {3, 5, 6, 7, 78, 100};
        Integer[] array2 = {5, 6, 7, 8, 9};
        Integer[] array3 = {2, 6, 7};
        Integer[] merged1 = merge(array1, array2);
        Arrays.sort(merged1);
        Integer[] merged2 = merge(array1, array2, array3);
        Arrays.sort(merged2);
        printArray(merged1);
        printArray(merged2);

    }

    public static void printArray(Integer[] x) {
        System.out.println("--ToString--");
        for (Integer var : x) {
            System.out.println(var);
        }
        System.out.println("----");

    }
}

public static int[] sortMultipleArrays(int[]... arrays) {
    return Arrays.stream(arrays)
                 .flatMapToInt(Arrays::stream)
                 .sorted()
                 .toArray();
}