Am I following a good approach? - sorting

Question

Please find the link to the discussed problem.
Sorting | Amazon Interview Question
I followed this following approach by taking random arrays. Would want your suggestions on what other approaches can be followed to solve the problem:-
public class ThreeMachineInsertionSorting {
public static void main(String[] args) {
int[] ar1 = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,-10};
int[] ar2 = { 20, 19, 18, 17, 16, 15, 14, 23, 12, 11, 10 };
int[] ar3 = { 20, 19, 21, 122, 10, 9, 11, 12, 4, 13, 18, 17 };
performInsertionSort(ar1, ar2, ar3);
}
private static void performInsertionSort(int[] ar1, int[] ar2, int[] ar3) {
int[][] arrayOfArrays = { ar1, ar2, ar3 };
int [] unSortedArray= mergeArrays(ar1,ar2,ar3,arrayOfArrays);
int i,j,key;
for(i=1;i<unSortedArray.length;i++){
key= unSortedArray[i];
j=i-1;
while(j>=0 && key<unSortedArray[j]){
unSortedArray[j+1] = unSortedArray[j];
j--;
}
unSortedArray[j+1] = key;
}
System.out.println("Size of the unSorted array is :=" + unSortedArray.length);
shareLoad(unSortedArray, arrayOfArrays);
}
private static void shareLoad(int[] sortedArray, int[][] arrayOfArrays) {
int loadFactor = sortedArray.length/3;
int index=0;
while(index<sortedArray.length){
for(int [] ar : arrayOfArrays){
for(int i=0; i<ar.length;i++){
if(i<=loadFactor){
ar[i] = sortedArray[index];
index++;
}
}
}
}
for(int [] ar : arrayOfArrays){
System.out.println("******************************************array properties**************************************");
System.out.println("Size of array::" + ar.length);
for(int i=0; i<ar.length;i++){
System.out.print(ar[i]+" ");
}
System.out.println("\n******************************************************************");
}
}
private static int[] mergeArrays(int[] ar1, int[] ar2, int[] ar3,int[][] arrayOfArrays ) {
int[] colaboratedArray = new int[ar1.length + ar2.length + ar3.length];
System.out.println("Length of multi-dimensional array :-"
+ arrayOfArrays.length);
int i = 0;
while (i < colaboratedArray.length) {
for (int[] ar : arrayOfArrays) {
for (int j = 0; j < ar.length; j++) {
colaboratedArray[i++] = ar[j];
}
}
}
return colaboratedArray;
}
}

Answer 1

Here is a bit of a naive solution.
Sort M1, M2 and M3 using in-place sorting algorithm.
Combine M1 and M3 by finding out the point where all elements from M1 can be swapped out for smaller elements in M3.
To find this point take 1/9 of the numbers in M3 and move to the buffer in M1. Notice that 1/9 of the numbers is exactly the 10% capacity available. We start with the smallest bucket in M3 and compare it to the largest bucket in M1. Just by comparing the largest value from the M3 bucket and the smallest value from the M1 bucket we can determine if we can swap them out completely or not. If we can then move the bucket from M1 to M3 and bring in new bucket from M3. Do this until we have M1 and M3 partitioned.
Now we must sort M1 and M3 again. Now we must take the smallest elements from M2 and move them to M1 until we have M1 and M2 partitioned. After that is done we can sort M1 and M2. Notice that M1 is now finished.
Finish by partitioning M2 and M3 and then sort both and the problem is solved.
Notice that this solution requires us to sort all machines three times, and each data element is in worst case moved 3 times between machines.
This solution can be improved if we can find the median of two unsorted sets, then we can partition the sets according to this median and then transferring elements, and only sort in the end once we know that the final numbers are on each machine.
It can be further improved if we can find the Kth largest element of 3 unsorted sets efficiently without transferring data.