# Merging two unsorted arrays in sorted order

Write a SortedMerge() function that takes two lists, each of which is unsorted, and merges the two together into one new list which is in sorted (increasing) order. SortedMerge() should return the new list.

Examples :

```Input : a[] = {10, 5, 15}
b[] = {20, 3, 2}
Output : Merge List :
{2, 3, 5, 10, 15, 20}

Input : a[] = {1, 10, 5, 15}
b[] = {20, 0, 2}
Output : Merge List :
{0, 1, 2, 5, 10, 15, 20}```

There are many cases to deal with: either â€˜aâ€™ or â€˜bâ€™ may be empty, during processing either â€˜aâ€™ or â€˜bâ€™ may run out first, and finally, thereâ€™s the problem of starting the result list empty and building it up while going through â€˜aâ€™ and â€˜bâ€™.

Method 1 (first Concatenate then Sort): In this case, we first append the two unsorted lists. Then we simply sort the concatenated list.

Implementation:

## C++

 `// CPP program to merge two unsorted lists  ` `// in sorted order ` `#include ` `using` `namespace` `std; ` ` `  `// Function to merge array in sorted order ` `void` `sortedMerge(``int` `a[], ``int` `b[], ``int` `res[],  ` `                                ``int` `n, ``int` `m) ` `{ ` `    ``// Concatenate two arrays ` `    ``int` `i = 0, j = 0, k = 0; ` `    ``while` `(i < n) { ` `        ``res[k] = a[i]; ` `        ``i += 1; ` `        ``k += 1; ` `    ``} ` `    ``while` `(j < m) { ` `        ``res[k] = b[j]; ` `        ``j += 1; ` `        ``k += 1; ` `    ``} ` ` `  `    ``// sorting the res array ` `    ``sort(res, res + n + m); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 10, 5, 15 }; ` `    ``int` `b[] = { 20, 3, 2, 12 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]); ` `    ``int` `m = ``sizeof``(b) / ``sizeof``(b[0]); ` ` `  `    ``// Final merge list ` `    ``int` `res[n + m]; ` `    ``sortedMerge(a, b, res, n, m); ` ` `  `    ``cout << ``"Sorted merged list :"``; ` `    ``for` `(``int` `i = 0; i < n + m; i++) ` `        ``cout << ``" "` `<< res[i]; ` `    ``cout << ``"n"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java Code for Merging two unsorted ` `// arrays in sorted order ` `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``// Function to merge array in sorted order ` `    ``public` `static` `void` `sortedMerge(``int` `a[], ``int` `b[],  ` `                                   ``int` `res[], ``int` `n,  ` `                                   ``int` `m) ` `    ``{ ` `        ``// Concatenate two arrays ` `        ``int` `i = ``0``, j = ``0``, k = ``0``; ` `        ``while` `(i < n) { ` `            ``res[k] = a[i]; ` `            ``i++; ` `            ``k++; ` `        ``} ` `         `  `        ``while` `(j < m) { ` `            ``res[k] = b[j]; ` `            ``j++; ` `            ``k++; ` `        ``} ` `     `  `        ``// sorting the res array ` `        ``Arrays.sort(res); ` `    ``} ` `     `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `a[] = { ``10``, ``5``, ``15` `}; ` `        ``int` `b[] = { ``20``, ``3``, ``2``, ``12` `}; ` `        ``int` `n = a.length; ` `        ``int` `m = b.length; ` `     `  `        ``// Final merge list ` `        ``int` `res[]=``new` `int``[n + m]; ` `        ``sortedMerge(a, b, res, n, m); ` `     `  `        ``System.out.print(``"Sorted merged list :"``); ` `        ``for` `(``int` `i = ``0``; i < n + m; i++) ` `            ``System.out.print(``" "` `+ res[i]);  ` `    ``} ` `} ` ` `  `// This code is contributed by Arnav Kr. Mandal.  `

## Python3

 `# Python program to merge two unsorted lists  ` `# in sorted order ` ` `  `# Function to merge array in sorted order ` `def` `sortedMerge(a, b, res, n, m): ` `    ``# Concatenate two arrays ` `    ``i, j, k ``=` `0``, ``0``, ``0` `    ``while` `(i < n): ` `        ``res[k] ``=` `a[i] ` `        ``i ``+``=` `1` `        ``k ``+``=` `1` `    ``while` `(j < m): ` `        ``res[k] ``=` `b[j] ` `        ``j ``+``=` `1` `        ``k ``+``=` `1` `  `  `    ``# sorting the res array ` `    ``res.sort() ` `  `  `# Driver code ` `a ``=` `[ ``10``, ``5``, ``15` `] ` `b ``=` `[ ``20``, ``3``, ``2``, ``12` `] ` `n ``=` `len``(a) ` `m ``=` `len``(b) ` ` `  `# Final merge list ` `res ``=` `[``0` `for` `i ``in` `range``(n ``+` `m)] ` `sortedMerge(a, b, res, n, m) ` `print` `(``"Sorted merged list :"``) ` `for` `i ``in` `range``(n ``+` `m): ` `    ``print``(res[i],end``=``" "``) ` `     `  `# This code is contributed by Sachin Bisht     `

## C#

 `// C# Code for Merging two  ` `// unsorted arrays in sorted order ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Function to merge array in sorted order ` `    ``public` `static` `void` `sortedMerge(``int` `[]a, ``int` `[]b,  ` `                                   ``int` `[]res, ``int` `n,  ` `                                   ``int` `m) ` `    ``{ ` `        ``// Concatenate two arrays ` `        ``int` `i = 0, j = 0, k = 0; ` `        ``while` `(i < n) { ` `            ``res[k] = a[i]; ` `            ``i++; ` `            ``k++; ` `        ``} ` `         `  `        ``while` `(j < m) { ` `            ``res[k] = b[j]; ` `            ``j++; ` `            ``k++; ` `        ``} ` `     `  `        ``// sorting the res array ` `        ``Array.Sort(res); ` `    ``} ` `     `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int` `[]a = {10, 5, 15}; ` `        ``int` `[]b = {20, 3, 2, 12}; ` `        ``int` `n = a.Length; ` `        ``int` `m = b.Length; ` `     `  `        ``// Final merge list ` `        ``int` `[]res=``new` `int``[n + m]; ` `        ``sortedMerge(a, b, res, n, m); ` `     `  `        ``Console.Write(``"Sorted merged list :"``); ` `        ``for` `(``int` `i = 0; i < n + m; i++) ` `            ``Console.Write(``" "` `+ res[i]);  ` `    ``} ` `} ` ` `  `// This code is contributed by nitin mittal. `

## PHP

 ` `

## Javascript

 ` `

Output

`Sorted merged list : 2 3 5 10 12 15 20n`

Time Complexity: O ( (n + m) (log(n + m)) )
Auxiliary Space: O ( (n + m) )

Method 2 (First Sort then Merge): We first sort both the given arrays separately. Then we simply merge two sorted arrays.

Implementation:

## C++

 `// CPP program to merge two unsorted lists  ` `// in sorted order ` `#include ` `using` `namespace` `std; ` ` `  `// Function to merge array in sorted order ` `void` `sortedMerge(``int` `a[], ``int` `b[], ``int` `res[],  ` `                                ``int` `n, ``int` `m) ` `{ ` `    ``// Sorting a[] and b[] ` `    ``sort(a, a + n); ` `    ``sort(b, b + m); ` ` `  `    ``// Merge two sorted arrays into res[] ` `    ``int` `i = 0, j = 0, k = 0; ` `    ``while` `(i < n && j < m) { ` `        ``if` `(a[i] <= b[j]) { ` `            ``res[k] = a[i]; ` `            ``i += 1; ` `            ``k += 1; ` `        ``} ``else` `{ ` `            ``res[k] = b[j]; ` `            ``j += 1; ` `            ``k += 1; ` `        ``} ` `    ``}     ` `    ``while` `(i < n) {  ``// Merging remaining ` `                     ``// elements of a[] (if any) ` `        ``res[k] = a[i]; ` `        ``i += 1; ` `        ``k += 1; ` `    ``}     ` `    ``while` `(j < m) {   ``// Merging remaining ` `                     ``// elements of b[] (if any) ` `        ``res[k] = b[j]; ` `        ``j += 1; ` `        ``k += 1; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 10, 5, 15 }; ` `    ``int` `b[] = { 20, 3, 2, 12 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]); ` `    ``int` `m = ``sizeof``(b) / ``sizeof``(b[0]); ` ` `  `    ``// Final merge list ` `    ``int` `res[n + m]; ` ` `  `    ``sortedMerge(a, b, res, n, m); ` ` `  `    ``cout << ``"Sorted merge list :"``; ` `    ``for` `(``int` `i = 0; i < n + m; i++) ` `        ``cout << ``" "` `<< res[i]; ` `    ``cout << ``"n"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// JAVA Code for Merging two unsorted  ` `// arrays in sorted order ` `import` `java.util.*; ` ` `  `class` `GFG { ` `     `  `    ``// Function to merge array in sorted order ` `    ``public` `static` `void` `sortedMerge(``int` `a[], ``int` `b[], ` `                                  ``int` `res[], ``int` `n, ` `                                            ``int` `m) ` `    ``{ ` `        ``// Sorting a[] and b[] ` `        ``Arrays.sort(a); ` `        ``Arrays.sort(b); ` `      `  `        ``// Merge two sorted arrays into res[] ` `        ``int` `i = ``0``, j = ``0``, k = ``0``; ` `        ``while` `(i < n && j < m) { ` `            ``if` `(a[i] <= b[j]) { ` `                ``res[k] = a[i]; ` `                ``i += ``1``; ` `                ``k += ``1``; ` `            ``} ``else` `{ ` `                ``res[k] = b[j]; ` `                ``j += ``1``; ` `                ``k += ``1``; ` `            ``} ` `        ``}     ` `         `  `        ``while` `(i < n) {  ``// Merging remaining ` `                         ``// elements of a[] (if any) ` `            ``res[k] = a[i]; ` `            ``i += ``1``; ` `            ``k += ``1``; ` `        ``}     ` `        ``while` `(j < m) {   ``// Merging remaining ` `                         ``// elements of b[] (if any) ` `            ``res[k] = b[j]; ` `            ``j += ``1``; ` `            ``k += ``1``; ` `        ``} ` `    ``} ` `     `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `a[] = { ``10``, ``5``, ``15` `}; ` `        ``int` `b[] = { ``20``, ``3``, ``2``, ``12` `}; ` `        ``int` `n = a.length; ` `        ``int` `m = b.length; ` `      `  `        ``// Final merge list ` `        ``int` `res[] = ``new` `int``[n + m]; ` `        ``sortedMerge(a, b, res, n, m); ` `      `  `        ``System.out.print( ``"Sorted merged list :"``); ` `        ``for` `(``int` `i = ``0``; i < n + m; i++) ` `            ``System.out.print(``" "` `+ res[i]);    ` `    ``} ` `} ` `// This code is contributed by Arnav Kr. Mandal. `

## Python3

 `# Python program to merge two unsorted lists  ` `# in sorted order ` ` `  `# Function to merge array in sorted order ` `def` `sortedMerge(a, b, res, n, m): ` `    ``# Sorting a[] and b[] ` `    ``a.sort() ` `    ``b.sort() ` `     `  `    ``# Merge two sorted arrays into res[] ` `    ``i, j, k ``=` `0``, ``0``, ``0` `    ``while` `(i < n ``and` `j < m): ` `        ``if` `(a[i] <``=` `b[j]): ` `            ``res[k] ``=` `a[i] ` `            ``i ``+``=` `1` `            ``k ``+``=` `1` `        ``else``: ` `            ``res[k] ``=` `b[j] ` `            ``j ``+``=` `1` `            ``k ``+``=` `1` `             `  `    ``while` `(i < n):  ``# Merging remaining ` `                    ``# elements of a[] (if any) ` `        ``res[k] ``=` `a[i] ` `        ``i ``+``=` `1` `        ``k ``+``=` `1` `         `  `    ``while` `(j < m):  ``# Merging remaining ` `                    ``# elements of b[] (if any) ` `        ``res[k] ``=` `b[j] ` `        ``j ``+``=` `1` `        ``k ``+``=` `1` `  `  `# Driver code ` `a ``=` `[ ``10``, ``5``, ``15` `] ` `b ``=` `[ ``20``, ``3``, ``2``, ``12` `] ` `n ``=` `len``(a) ` `m ``=` `len``(b) ` ` `  `# Final merge list ` `res ``=` `[``0` `for` `i ``in` `range``(n ``+` `m)] ` `sortedMerge(a, b, res, n, m) ` `print` `(``"Sorted merged list :"``) ` `for` `i ``in` `range``(n ``+` `m): ` `    ``print``(res[i],end``=``" "``) ` `     `  `# This code is contributed by Sachin Bisht     `

## C#

 `// C# Code for Merging two unsorted  ` `// arrays in sorted order ` `using` `System;  ` ` `  `class` `GFG { ` `     `  `    ``// Function to merge array in  ` `    ``// sorted order ` `    ``static` `void` `sortedMerge(``int` `[]a, ``int` `[]b, ` `                     ``int` `[]res, ``int` `n, ``int` `m) ` `    ``{ ` `         `  `        ``// Sorting a[] and b[] ` `        ``Array.Sort(a); ` `        ``Array.Sort(b); ` `     `  `        ``// Merge two sorted arrays into res[] ` `        ``int` `i = 0, j = 0, k = 0; ` `         `  `        ``while` `(i < n && j < m) ` `        ``{ ` `            ``if` `(a[i] <= b[j]) ` `            ``{ ` `                ``res[k] = a[i]; ` `                ``i += 1; ` `                ``k += 1; ` `            ``}  ` `            ``else`  `            ``{ ` `                ``res[k] = b[j]; ` `                ``j += 1; ` `                ``k += 1; ` `            ``} ` `        ``}  ` `         `  `        ``while` `(i < n) ` `        ``{  ` `             `  `            ``// Merging remaining ` `            ``// elements of a[] (if any) ` `            ``res[k] = a[i]; ` `            ``i += 1; ` `            ``k += 1; ` `        ``}  ` `        ``while` `(j < m) ` `        ``{ ` `             `  `            ``// Merging remaining ` `            ``// elements of b[] (if any) ` `            ``res[k] = b[j]; ` `            ``j += 1; ` `            ``k += 1; ` `        ``} ` `    ``} ` `     `  `    ``/* Driver program to test ` `    ``above function */` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int` `[]a = { 10, 5, 15 }; ` `        ``int` `[]b = { 20, 3, 2, 12 }; ` `        ``int` `n = a.Length; ` `        ``int` `m = b.Length; ` `     `  `        ``// Final merge list ` `        ``int` `[]res = ``new` `int``[n + m]; ` `        ``sortedMerge(a, b, res, n, m); ` `     `  `        ``Console.Write( ``"Sorted merged list :"``); ` `        ``for` `(``int` `i = 0; i < n + m; i++) ` `            ``Console.Write(``" "` `+ res[i]);  ` `    ``} ` `} ` ` `  `// This code is contributed by nitin mittal. `

## Javascript

 ``

Output

`Sorted merge list : 2 3 5 10 12 15 20n`

Time Complexity: O (nlogn + mlogm + (n + m))
Space Complexity: O ( (n + m) )

It is obvious from above time complexities that method 2 is better than method 1.

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next