Combing two arrays in ascending order with unknown values inside the array

Question

I have managed to create both arrays, however I can't figure out how to combine the two arrays. Every tutorial I see merges them as such:

int[] arr1 = {3, 3, 5, 6, 8, 9};
int[] arr2 = {3, 4, 5, 6};
// Output: 3, 4, 5, 6, 8, 9

What I need is something that would output: 3, 3, 3, 4, 5, 5, 6, 6, 8, 9 Here is the code I have written so far:

import java.util.Scanner;

public class Merger {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int[] arr1 = new int[10000];

        int[] arr2 = new int[10000];
        int[] merged = new int[20000];
        int a1 = 0;
        int a2 = 0;
        int size = -1;
        int size2 = -1;
        int sizecheck = 0;
        int size2check = 0;
        System.out
                .println("Enter the values for the first array, up to 10,000 values, enter a negative number to quit");
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = scan.nextInt();
            merged[i] = arr1[i];
            if (arr1[i] <= 0) {
                break;
            }
            if (size <= arr1[i]) {
                size = arr1[i];
                sizecheck++;
            }
            a1++;
        }
        System.out
                .println("Enter the values for the second array, up to 10,000 values, enter a negative number to quit");
        for (int i = 0; i < arr2.length; i++) {
            arr2[i] = scan.nextInt();
            merged[i + a1] = arr2[i];
            if (arr2[i] <= 0) {
                break;
            }
            if (size2 <= arr2[i]) {
                size2 = arr2[i];
                size2check++;
            }
            a2++;
        }
        System.out.println("First Array: ");
        for (int i = 0; i < a1; i++) {
            System.out.print(" " + arr1[i]);
        }
        System.out.println("\nSecond Array: ");
        for (int i = 0; i < a2; i++) {
            System.out.print(" " + arr2[i]);
        }
    }
}

This prints both arrays out, however does not combine and sort the two.

Answer 1

You can use System.arraycopy method for this purpose:

int[] arr1 = {3, 3, 5, 6, 8, 9};
int[] arr2 = {3, 4, 5, 6};

// create a new array of total length
int[] arr3 = new int[arr1.length + arr2.length];

// copy first array to the beginning of the total array
System.arraycopy(arr1, 0, arr3, 0, arr1.length);
// copy second array to the end of the total array
System.arraycopy(arr2, 0, arr3, arr1.length, arr2.length);

// sort the total array
Arrays.sort(arr3);

System.out.println(Arrays.toString(arr3));
// [3, 3, 3, 4, 5, 5, 6, 6, 8, 9]

Answer 2

A simple solution can be written using the classes, Arrays and System.

Steps:

1. Copy elements of arr1[] into a new array (say, output[]) whose size is the sum of the sizes of the given arrays.
2. Copy the elements of arr2[], after the element of arr1[], into output[]
3. Sort output[]

Demo:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = { 3, 3, 5, 6, 8, 9 };
        int[] arr2 = { 3, 4, 5, 6 };

        // Copy elements of arr1[] into a new array whose size is the sum of the sizes
        // of the given arrays
        int[] output = Arrays.copyOf(arr1, arr1.length + arr2.length);

        // Copy the elements of arr2[], after the element of arr1[], into output[]
        System.arraycopy(arr2.clone(), 0, output, arr1.length, arr2.length);

        // Sort output[]
        Arrays.sort(output);

        // Display output[]
        System.out.println(Arrays.toString(output));
    }
}

Output:

[3, 3, 3, 4, 5, 5, 6, 6, 8, 9]

Answer 3

public class Merger {

    public static void main(String[] args) {
        int[] arr1 = { 3, 3, 5, 6, 8, 9 };
        int[] arr2 = { 3, 4, 5, 6 };
        int[] res = merge(arr1, arr2);
        System.out.println(Arrays.toString(res));
    }

    public static int[] merge(int[] arr1, int[] arr2) {
        int[] res = new int[arr1.length + arr2.length];

        for (int i = 0, a1 = 0, a2 = 0; i < res.length; i++) {
            if (a1 == arr1.length)
                res[i] = arr2[a2++];
            else if (a2 == arr2.length)
                res[i] = arr1[a1++];
            else
                res[i] = arr1[a1] <= arr2[a2] ? arr1[a1++] : arr2[a2++];
        }

        return res;
    }
}

Answer 4

The easiest way is to use a Stream.

int[] arr1 = {3, 3, 5, 6, 8, 9};
int[] arr2 = {3, 4, 5, 6};

• Stream both arrays.
• flatMap them to a single IntStream
• sort them
• convert to an array

int [] combined = Stream.of(arr1,arr2)
                       .flatMapToInt(Arrays::stream)
                       .sorted()
                       .toArray();

System.out.println(Arrays.toString(combined));

Prints

[3, 3, 3, 4, 5, 5, 6, 6, 8, 9]

A non-stream approach can be done as follows:

// increase arr1 to make room for arr2
int oldLen = arr1.length;
arr1 = Arrays.copyOf(arr1, arr1.length+arr2.length);

// copy arr2 starting at 0, to arr1 starting at the old length
// positon of arr1 for a length of arr2
System.arraycopy(arr2, 0, arr1, oldLen, arr2.length);

// sort and print
Arrays.sort(arr1);
System.out.println(Arrays.toString(arr1));

Prints

[3, 3, 3, 4, 5, 5, 6, 6, 8, 9]

Although your question, as asked, said nothing about merging sorted arrays, here is how you would do it.

The algorithm is simple. Just iterate thru each array and compare current values.

• if arr1[i] <= arr2[k], copy arr1[i] to result, advance i by 1
• else copy arr2[k] to result, advance k by 1.
• in all cases the index to result, r, is advanced by 1

public int[] merge(int[] arr1, int[] arr2) {
    // result array
    int[] result = new int[arr1.length + arr2.length];

    int r = 0;
    int k = 0;
    int i = 0;
    // Iterate thru the arrays, copying the lowest or equal value
    // to the target array.  This process will cease when one of the arrays
    // has been fully processed.


    for (; i < arr1.length && k < arr2.length; ) {
        for (; k < arr2.length && i < arr1.length;) {
            if (arr1[i] <= arr2[k]) {
                result[r++] = arr1[i++]; 
            }else {
                 result[r++] = arr2[k++];
            }               
        }
    }

Having reached this far in the algorithm, one of the arrays must have been completely processed. So try and copy both. For the empty array, the while loop basically acts like an if statement.

    while (i < arr1.length) {
        result[r++] = arr1[i++]; 
    }
    while (k < arr2.length) {
        result[r++] = arr2[k++]; 
    }
    // return the result
    return result;
}

Answer 5

I assume that you are not yet familiar with Streams, but I would like to give you an example of what you can do with them.

Add import

import java.util.stream.IntStream;

Add this at the end of your main method

System.out.println(""); 
IntStream arr1Stream = IntStream.of(arr1).limit(a1); //creates an InStream with the first a1 values of arr1
IntStream arr2Stream = IntStream.of(arr2).limit(a2); 
int[] both = IntStream.concat(arr1Stream, arr2Stream).sorted().toArray(); //combines the two streams, sorts them an converts them to an Array
System.out.println(Arrays.toString(both)); //easy way to print an array

Answer 6

Here's the code ! There may be a faster/easier way to do it but this one works as long as the 2 arrays are sorted

public static void main(String[] args) {
    int[] a1 = {1, 2, 3, 5};
    int[] a2 = {1, 3, 4, 4, 4, 5};
    int[] a3 = merge(a1, a2);
    for (int i : a3) {
        System.out.print(i);
    }
}

public static int[] merge(int[] a1, int[] a2) {
    int[] a3 = new int[a1.length + a2.length];
    int indexA1 = 0;
    int indexA2 = 0;
    for (int i = 0; i < a3.length; i++) {
        int n;
        if (indexA1 == a1.length && indexA2 < a2.length) {
            n = a2[indexA2];
            indexA2++;
        } else if (indexA1 < a1.length && indexA2 == a2.length) {
            n = a1[indexA1];
            indexA1++;
        } else {
            if (a1[indexA1] < a2[indexA2]) {
                n = a1[indexA1];
                indexA1++;
            } else {
                n = a2[indexA2];
                indexA2++;
            }
        }
        a3[i] = n;
    }
    return a3;
}