Merge K sorted arrays

问题

I am given k sorted arrays and need to merge them into one sorted array. We are assuming that n is the total number of elements in all the input arrays and that k=3.

public class Merge {

// Create a mergeklists() to merge 3 sorted arrays into one sorted array
// Input: 3 sorted arrays a1[], a2[], a3[]
// Output: one sorted array a[] that contains all the elements from input arrays

public static void merge3lists(int[] a1, int[] a2, int[] a3, int[] a)
{
    int i=0;
    int j=0;
    int h=0;
    int n = a1.length + a2.length + a3.length;
    for(int k;  a.length < n-1; k++){
        if(a1[i] < a2[j]){
            k = a1[i];
            i++;
        }
        else if(a2[j] < a3[h]){
            k = a2[j];
            j++;
        }
        else{
            k = a3[h];
            h++;
        }
    }



}   


public static void main(String[] args) {


    int[] l1 = {1,5,9,10,20};

    int[] l2 = {2,4,5,6,7,9,15};

    int[] l3 = {3,8,13,15,22};

    int[] newl = new int[l1.length+l2.length+l3.length];


    merge3lists(l1,l2,l3,newl);
    for(int i = 0; i< newl.length; i++)
    {
        System.out.print(newl[i]+ " ");
    }


}

}

I know that the integers I am using (I,j,and h) are messing up the problem, but I don't think I can use i while comparing all the arrays. I need to use the declared array a, but I'm not sure how to reference it in this case.

回答1:

Looks like a preparation exercise to motivate the introduction of array of arrays :)

Number the indices analogous to the lists to avoid confusion.

Identify the list with the smallest element at its current index. Avoid reading beyond the end of the array, as it will result in an exception.

Take this element and proceed.

int i1=0;
int i2=0;
int i3=0;
int n = a1.length + a2.length + a3.length;
for( int k = 0;  k < n; k++) {
  int advance = 0;
  int value = Integer.MAX_VALUE;
  if (i1 < a1.length && a1[i1] <= value) {
    advance = 1;
    value = a1[i1]; 
  }
  if (i2 < a2.length && a2[i2] <= value) {
    advance = 2;
    value = a2[i2]; 
  }
  if (i3 < a3.length && a3[i3] <= value) {
    advance = 3;
    value = a3[i3]; 
  }
  a[k] = value;
  switch(advance) {
  case 1: i1++; break;
  case 2: i2++; break;
  case 3: i3++; break;
  }
}

回答2:

To have to method merge an arbitrary number of arrays (k), you need to make the method use varargs.

It would also be better to have the method create the result array for you.

You then loop until the result array is filled. For each iteration, you find the smallest of the next value from each source array, and add that to the result array, and step forward in the source array you picked the value from.

Like this:

public static int[] mergeArrays(int[]... arrays) {
    // Create result array
    int n = 0;
    for (int[] a : arrays)
        n += a.length;
    int[] result = new int[n];

    // Start at index 0 in each source array
    int[] idx = new int[arrays.length];

    // Merge source arrays into result array
    for (int i = 0; i < n; i++) {

        // Find smallest value
        int minJ = -1, minVal = 0;
        for (int j = 0; j < arrays.length; j++) {
            if (idx[j] < arrays[j].length) {
                int val = arrays[j][idx[j]];
                if (minJ == -1 || val < minVal) {
                    minJ = j;
                    minVal = val;
                }
            }
        }

        // Add to result array and step forward in appropriate source array
        result[i] = minVal;
        idx[minJ]++;
    }
    return result;
}

Test

int[] merged = mergeArrays(new int[] { 23, 39, 63, 68 },
                           new int[] { 11, 21, 76 },
                           new int[] {  5, 10, 37, 80 },
                           new int[] { 30, 49, 50, 94 },
                           new int[] { 13, 25, 48 });
System.out.println(Arrays.toString(merged));

Output

[5, 10, 11, 13, 21, 23, 25, 30, 37, 39, 48, 49, 50, 63, 68, 76, 80, 94]

回答3:

A more efficient algorithm is to use a min-heap.

The algorithm is roughly described as follows:

First, construct a min-heap of size k (in this case size 3 for the three lists) taking the minimum elements in each list. You would then delete then the minimum element from the heap (noting which list it came from), add it to your newly constructed list, and then insert the next element from that same list which it was initially drawn from.

The time complexity would drop from O(n * k) to O(n * log(k)). Where n is the total number of elements in the final sorted list.

https://cs.stackexchange.com/questions/12853/heap-give-an-on-lg-k-time-algorithm-to-merge-k-sorted-lists-into-one-so

来源：https://stackoverflow.com/questions/47146881/merge-k-sorted-arrays