Open in App
Not now

# Merge k sorted arrays | Set 1

• Difficulty Level : Hard
• Last Updated : 16 Feb, 2023

Given K sorted arrays of size N each, merge them and print the sorted output.

Examples:

Input: K = 3, N = 4, arr = { {1, 3, 5, 7}, {2, 4, 6, 8}, {0, 9, 10, 11}}
Output: 0 1 2 3 4 5 6 7 8 9 10 11
Explanation: The output array is a sorted array that contains all the elements of the input matrix.

Input: k = 4, n = 4, arr = { {1, 5, 6, 8}, {2, 4, 10, 12}, {3, 7, 9, 11}, {13, 14, 15, 16}}
Output: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Explanation: The output array is a sorted array that contains all the elements of the input matrix.

Recommended Practice

## Naive Approach for Merging k sorted arrays:

Create an output array of size (N * K) and then copy all the elements into the output array followed by sorting.

Follow the given steps to solve the problem:

• Create an output array of size N * K.
• Traverse the matrix from start to end and insert all the elements in the output array.
• Sort and print the output array.

Below is the implementation of the above approach:

## C++14

 `// C++ program to merge K sorted arrays of size n each. ` ` `  `#include ` `using` `namespace` `std; ` `#define N 4 ` ` `  `// A utility function to print array elements ` `void` `printArray(``int` `arr[], ``int` `size) ` `{ ` `    ``for` `(``int` `i = 0; i < size; i++) ` `        ``cout << arr[i] << ``" "``; ` `} ` ` `  `// This function takes an array of arrays as an argument and ` `// All arrays are assumed to be sorted. It merges them ` `// together and prints the final sorted output. ` `void` `mergeKArrays(``int` `arr[][N], ``int` `a, ``int` `output[]) ` `{ ` `    ``int` `c = 0; ` ` `  `    ``// traverse the matrix ` `    ``for` `(``int` `i = 0; i < a; i++) { ` `        ``for` `(``int` `j = 0; j < N; j++) ` `            ``output = arr[i][j]; ` `    ``} ` ` `  `    ``// sort the array ` `    ``sort(output, output + N * a); ` `} ` ` `  `// Driver's code ` `int` `main() ` `{ ` `    ``// Change N at the top to change number of elements ` `    ``// in an array ` `    ``int` `arr[][N] = { { 2, 6, 12, 34 }, ` `                     ``{ 1, 9, 20, 1000 }, ` `                     ``{ 23, 34, 90, 2000 } }; ` `    ``int` `K = ``sizeof``(arr) / ``sizeof``(arr[0]); ` ` `  `    ``int` `output[N * K]; ` ` `  `    ``// Function call ` `    ``mergeKArrays(arr, 3, output); ` ` `  `    ``cout << ``"Merged array is "` `<< endl; ` `    ``printArray(output, N * K); ` ` `  `    ``return` `0; ` `}`

## Java

 `// Java program to merge K sorted arrays of size N each. ` ` `  `import` `java.io.*; ` `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``// This function takes an array of arrays as an argument ` `    ``// and ` `    ``// All arrays are assumed to be sorted. It merges them ` `    ``// together and prints the final sorted output. ` `    ``public` `static` `void` `mergeKArrays(``int``[][] arr, ``int` `a, ` `                                    ``int``[] output) ` `    ``{ ` `        ``int` `c = ``0``; ` ` `  `        ``// traverse the matrix ` `        ``for` `(``int` `i = ``0``; i < a; i++) { ` `            ``for` `(``int` `j = ``0``; j < ``4``; j++) ` `                ``output = arr[i][j]; ` `        ``} ` ` `  `        ``// sort the array ` `        ``Arrays.sort(output); ` `    ``} ` ` `  `    ``// A utility function to print array elements ` `    ``public` `static` `void` `printArray(``int``[] arr, ``int` `size) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < size; i++) ` `            ``System.out.print(arr[i] + ``" "``); ` `    ``} ` ` `  `    ``// Driver's code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[][] arr = { { ``2``, ``6``, ``12``, ``34` `}, ` `                        ``{ ``1``, ``9``, ``20``, ``1000` `}, ` `                        ``{ ``23``, ``34``, ``90``, ``2000` `} }; ` `        ``int` `K = ``4``; ` `        ``int` `N = ``3``; ` `        ``int``[] output = ``new` `int``[N * K]; ` ` `  `        ``// Function call ` `        ``mergeKArrays(arr, N, output); ` ` `  `        ``System.out.println(``"Merged array is "``); ` `        ``printArray(output, N * K); ` `    ``} ` `}`

## Python3

 `# Python3 program to merge k sorted arrays of size n each. ` ` `  `# This function takes an array of arrays as an argument ` `# and ` `# All arrays are assumed to be sorted. It merges them ` `# together and prints the final sorted output. ` ` `  ` `  `def` `mergeKArrays(arr, a, output): ` `    ``c ``=` `0` ` `  `    ``# traverse the matrix ` `    ``for` `i ``in` `range``(a): ` `        ``for` `j ``in` `range``(``4``): ` `            ``output ``=` `arr[i][j] ` `            ``c ``+``=` `1` ` `  `    ``# sort the array ` `    ``output.sort() ` ` `  `# A utility function to print array elements ` ` `  ` `  `def` `printArray(arr, size): ` `    ``for` `i ``in` `range``(size): ` `        ``print``(arr[i], end``=``" "``) ` ` `  ` `  `# Driver's code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=` `[[``2``, ``6``, ``12``, ``34``], [``1``, ``9``, ``20``, ``1000``], [``23``, ``34``, ``90``, ``2000``]] ` `    ``K ``=` `4` `    ``N ``=` `3` `    ``output ``=` `[``0` `for` `i ``in` `range``(N ``*` `K)] ` ` `  `    ``# Function call ` `    ``mergeKArrays(arr, N, output) ` ` `  `    ``print``(``"Merged array is "``) ` `    ``printArray(output, N ``*` `K) ` ` `  `# This code is contributed by umadevi9616 `

## C#

 `// C# program to merge K sorted arrays of size n each. ` `using` `System; ` `public` `class` `GFG { ` ` `  `    ``// This function takes an array of arrays as an argument ` `    ``// and ` `    ``// All arrays are assumed to be sorted. It merges them ` `    ``// together and prints the readonly sorted output. ` `    ``public` `static` `void` `mergeKArrays(``int``[, ] arr, ``int` `a, ` `                                    ``int``[] output) ` `    ``{ ` `        ``int` `c = 0; ` ` `  `        ``// traverse the matrix ` `        ``for` `(``int` `i = 0; i < a; i++) { ` `            ``for` `(``int` `j = 0; j < 4; j++) ` `                ``output = arr[i, j]; ` `        ``} ` ` `  `        ``// sort the array ` `        ``Array.Sort(output); ` `    ``} ` ` `  `    ``// A utility function to print array elements ` `    ``public` `static` `void` `printArray(``int``[] arr, ``int` `size) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < size; i++) ` `            ``Console.Write(arr[i] + ``" "``); ` `    ``} ` ` `  `    ``// Driver's code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int``[, ] arr = { { 2, 6, 12, 34 }, ` `                        ``{ 1, 9, 20, 1000 }, ` `                        ``{ 23, 34, 90, 2000 } }; ` `        ``int` `K = 4; ` `        ``int` `N = 3; ` `        ``int``[] output = ``new` `int``[N * K]; ` ` `  `        ``// Function call ` `        ``mergeKArrays(arr, N, output); ` `        ``Console.WriteLine(``"Merged array is "``); ` `        ``printArray(output, N * K); ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji`

## Javascript

 `// Javascript program to merge k sorted  ` `// arrays of size n each. ` ` `  `    ``// This function takes an array of  ` `    ``// arrays as an argument and ` `    ``// All arrays are assumed to be sorted.  ` `    ``// It merges them together and prints  ` `    ``// the final sorted output. ` `    ``function` `mergeKArrays(arr , a,  output) ` `    ``{ ` `        ``var` `c = 0; ` ` `  `        ``// traverse the matrix ` `        ``for` `(i = 0; i < a; i++) { ` `            ``for` `(j = 0; j < 4; j++) ` `                ``output = arr[i][j]; ` `        ``} ` ` `  `        ``// sort the array ` `        ``output.sort((a,b)=>a-b); ` `    ``} ` ` `  `    ``// A utility function to print array elements ` `    ``function` `printArray(arr , size) { ` `        ``for` `(i = 0; i < size; i++) ` `            ``document.write(arr[i] + ``" "``); ` `    ``} ` ` `  `    ``// Driver program to test above functions ` `     `  `        ``var` `arr = [ [ 2, 6, 12, 34 ],  ` `                    ``[ 1, 9, 20, 1000 ],  ` `                    ``[ 23, 34, 90, 2000 ] ]; ` `        ``var` `K = 4; ` `        ``var` `N = 3; ` `        ``var` `output = Array(N * K).fill(0); ` ` `  `        ``mergeKArrays(arr, N, output); ` ` `  `        ``document.write(``"Merged array is "``); ` `        ``printArray(output, N * K); ` ` `  ` `  `// This code contributed by Rajput-Ji`

Output

```Merged array is
1 2 6 9 12 20 23 34 34 90 1000 2000 ```

Time Complexity: O(N * K * log (N*K)), Since the resulting array is of size N*K.
Space Complexity: O(N * K), The output array is of size N * K.

## Merge K sorted arrays using merging:

The process begins with merging arrays into groups of two. After the first merge, there will be K/2 arrays remaining. Again merge arrays in groups, now K/4 arrays will be remaining. This is similar to merge sort. Divide K arrays into two halves containing an equal number of arrays until there are two arrays in a group. This is followed by merging the arrays in a bottom-up manner.

Follow the given steps to solve the problem:

• Create a recursive function that takes K arrays and returns the output array.
• In the recursive function, if the value of K is 1 then return the array else if the value of K is 2 then merge the two arrays in linear time and return the array.
• If the value of K is greater than 2 then divide the group of k elements into two equal halves and recursively call the function, i.e 0 to K/2 array in one recursive function and K/2 to K array in another recursive function.
• Print the output array.

Below is the implementation of the above approach:

## C++14

 `// C++ program to merge K sorted arrays of size n each. ` ` `  `#include ` `using` `namespace` `std; ` `#define N 4 ` ` `  `// Merge arr1[0..N1-1] and arr2[0..N2-1] into ` `// arr3[0..N1+N2-1] ` `void` `mergeArrays(``int` `arr1[], ``int` `arr2[], ``int` `N1, ``int` `N2, ` `                 ``int` `arr3[]) ` `{ ` `    ``int` `i = 0, j = 0, k = 0; ` ` `  `    ``// Traverse both array ` `    ``while` `(i < N1 && j < N2) { ` `        ``// Check if current element of first ` `        ``// array is smaller than current element ` `        ``// of second array. If yes, store first ` `        ``// array element and increment first array ` `        ``// index. Otherwise do same with second array ` `        ``if` `(arr1[i] < arr2[j]) ` `            ``arr3[k++] = arr1[i++]; ` `        ``else` `            ``arr3[k++] = arr2[j++]; ` `    ``} ` ` `  `    ``// Store remaining elements of first array ` `    ``while` `(i < N1) ` `        ``arr3[k++] = arr1[i++]; ` ` `  `    ``// Store remaining elements of second array ` `    ``while` `(j < N2) ` `        ``arr3[k++] = arr2[j++]; ` `} ` ` `  `// A utility function to print array elements ` `void` `printArray(``int` `arr[], ``int` `size) ` `{ ` `    ``for` `(``int` `i = 0; i < size; i++) ` `        ``cout << arr[i] << ``" "``; ` `} ` ` `  `// This function takes an array of arrays as an argument and ` `// All arrays are assumed to be sorted. It merges them ` `// together and prints the final sorted output. ` `void` `mergeKArrays(``int` `arr[][N], ``int` `i, ``int` `j, ``int` `output[]) ` `{ ` `    ``// If one array is in range ` `    ``if` `(i == j) { ` `        ``for` `(``int` `p = 0; p < N; p++) ` `            ``output[p] = arr[i][p]; ` `        ``return``; ` `    ``} ` ` `  `    ``// if only two arrays are left them merge them ` `    ``if` `(j - i == 1) { ` `        ``mergeArrays(arr[i], arr[j], N, N, output); ` `        ``return``; ` `    ``} ` ` `  `    ``// Output arrays ` `    ``int` `out1[N * (((i + j) / 2) - i + 1)], ` `        ``out2[N * (j - ((i + j) / 2))]; ` ` `  `    ``// Divide the array into halves ` `    ``mergeKArrays(arr, i, (i + j) / 2, out1); ` `    ``mergeKArrays(arr, (i + j) / 2 + 1, j, out2); ` ` `  `    ``// Merge the output array ` `    ``mergeArrays(out1, out2, N * (((i + j) / 2) - i + 1), ` `                ``N * (j - ((i + j) / 2)), output); ` `} ` ` `  `// Driver's code ` `int` `main() ` `{ ` `    ``// Change N at the top to change number of elements ` `    ``// in an array ` `    ``int` `arr[][N] = { { 2, 6, 12, 34 }, ` `                     ``{ 1, 9, 20, 1000 }, ` `                     ``{ 23, 34, 90, 2000 } }; ` `    ``int` `K = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``int` `output[N * K]; ` `    ``mergeKArrays(arr, 0, 2, output); ` ` `  `    ``// Function call ` `    ``cout << ``"Merged array is "` `<< endl; ` `    ``printArray(output, N * K); ` ` `  `    ``return` `0; ` `}`

## Java

 `// Java program to merge K sorted arrays of size n each. ` `import` `java.util.*; ` ` `  `class` `GFG { ` `    ``static` `final` `int` `N = ``4``; ` ` `  `    ``// Merge arr1[0..n1-1] and arr2[0..n2-1] into ` `    ``// arr3[0..n1+n2-1] ` `    ``static` `void` `mergeArrays(``int` `arr1[], ``int` `arr2[], ``int` `N1, ` `                            ``int` `N2, ``int` `arr3[]) ` `    ``{ ` `        ``int` `i = ``0``, j = ``0``, k = ``0``; ` ` `  `        ``// Traverse both array ` `        ``while` `(i < N1 && j < N2) { ` `            ``// Check if current element of first ` `            ``// array is smaller than current element ` `            ``// of second array. If yes, store first ` `            ``// array element and increment first array ` `            ``// index. Otherwise do same with second array ` `            ``if` `(arr1[i] < arr2[j]) ` `                ``arr3[k++] = arr1[i++]; ` `            ``else` `                ``arr3[k++] = arr2[j++]; ` `        ``} ` ` `  `        ``// Store remaining elements of first array ` `        ``while` `(i < N1) ` `            ``arr3[k++] = arr1[i++]; ` ` `  `        ``// Store remaining elements of second array ` `        ``while` `(j < N2) ` `            ``arr3[k++] = arr2[j++]; ` `    ``} ` ` `  `    ``// A utility function to print array elements ` `    ``static` `void` `printArray(``int` `arr[], ``int` `size) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < size; i++) ` `            ``System.out.print(arr[i] + ``" "``); ` `    ``} ` ` `  `    ``// This function takes an array of arrays as an argument ` `    ``// and All arrays are assumed to be sorted. It merges ` `    ``// them together and prints the final sorted output. ` `    ``static` `void` `mergeKArrays(``int` `arr[][], ``int` `i, ``int` `j, ` `                             ``int` `output[]) ` `    ``{ ` `        ``// if one array is in range ` `        ``if` `(i == j) { ` `            ``for` `(``int` `p = ``0``; p < N; p++) ` `                ``output[p] = arr[i][p]; ` `            ``return``; ` `        ``} ` ` `  `        ``// if only two arrays are left them merge them ` `        ``if` `(j - i == ``1``) { ` `            ``mergeArrays(arr[i], arr[j], N, N, output); ` `            ``return``; ` `        ``} ` ` `  `        ``// output arrays ` `        ``int``[] out1 = ``new` `int``[N * (((i + j) / ``2``) - i + ``1``)]; ` `        ``int``[] out2 = ``new` `int``[N * (j - ((i + j) / ``2``))]; ` ` `  `        ``// divide the array into halves ` `        ``mergeKArrays(arr, i, (i + j) / ``2``, out1); ` `        ``mergeKArrays(arr, (i + j) / ``2` `+ ``1``, j, out2); ` ` `  `        ``// merge the output array ` `        ``mergeArrays(out1, out2, N * (((i + j) / ``2``) - i + ``1``), ` `                    ``N * (j - ((i + j) / ``2``)), output); ` `    ``} ` ` `  `    ``// Driver's code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` ` `  `        ``// Change n at the top to change number of elements ` `        ``// in an array ` `        ``int` `arr[][] = { { ``2``, ``6``, ``12``, ``34` `}, ` `                        ``{ ``1``, ``9``, ``20``, ``1000` `}, ` `                        ``{ ``23``, ``34``, ``90``, ``2000` `} }; ` ` `  `        ``int` `K = arr.length; ` `        ``int``[] output = ``new` `int``[N * K]; ` ` `  `        ``// Function call ` `        ``mergeKArrays(arr, ``0``, ``2``, output); ` ` `  `        ``System.out.print(``"Merged array is "` `                         ``+ ``"\n"``); ` `        ``printArray(output, N * K); ` `    ``} ` `} ` ` `  `// This code is contributed by gauravrajput1`

## Python3

 `# Python program to merge K ` `# sorted arrays of size n each. ` `N ``=` `4` ` `  `# Merge arr1[0..n1-1] and arr2[0..n2-1] into ` `# arr3[0..n1+n2-1] ` ` `  ` `  `def` `mergeArrays(arr1, arr2, N1, N2, arr3): ` ` `  `    ``i, j, k ``=` `0``, ``0``, ``0` ` `  `    ``# Traverse both array ` `    ``while` `(i < N1 ``and` `j < N2): ` ` `  `        ``# Check if current element of first ` `        ``# array is smaller than current element ` `        ``# of second array. If yes, store first ` `        ``# array element and increment first array ` `        ``# index. Otherwise do same with second array ` `        ``if` `(arr1[i] < arr2[j]): ` `            ``arr3[k] ``=` `arr1[i] ` `            ``k ``+``=` `1` `            ``i ``+``=` `1` `        ``else``: ` `            ``arr3[k] ``=` `arr2[j] ` `            ``k ``+``=` `1` `            ``j ``+``=` `1` ` `  `    ``# Store remaining elements of first array ` `    ``while` `(i < N1): ` `        ``arr3[k] ``=` `arr1[i] ` `        ``k ``+``=` `1` `        ``i ``+``=` `1` ` `  `    ``# Store remaining elements of second array ` `    ``while` `(j < N2): ` `        ``arr3[k] ``=` `arr2[j] ` `        ``k ``+``=` `1` `        ``j ``+``=` `1` ` `  `# A utility function to print array elements ` ` `  ` `  `def` `printArray(arr, size): ` ` `  `    ``for` `i ``in` `range``(size): ` `        ``print``(arr[i], end``=``" "``) ` ` `  `# This function takes an array of arrays ` `# as an argument and all arrays are assumed ` `# to be sorted. It merges them together ` `# and prints the final sorted output. ` ` `  ` `  `def` `mergeKArrays(arr, i, j, output): ` ` `  `    ``global` `N ` ` `  `    ``# If one array is in range ` `    ``if` `(i ``=``=` `j): ` `        ``for` `p ``in` `range``(N): ` `            ``output[p] ``=` `arr[i][p] ` ` `  `        ``return` ` `  `    ``# If only two arrays are left ` `    ``# them merge them ` `    ``if` `(j ``-` `i ``=``=` `1``): ` `        ``mergeArrays(arr[i], arr[j], ` `                    ``N, N, output) ` `        ``return` ` `  `    ``# Output arrays ` `    ``out1 ``=` `[``0` `for` `i ``in` `range``(N ``*` `(((i ``+` `j) ``/``/` `2``) ``-` `i ``+` `1``))] ` `    ``out2 ``=` `[``0` `for` `i ``in` `range``(N ``*` `(j ``-` `((i ``+` `j) ``/``/` `2``)))] ` ` `  `    ``# Divide the array into halves ` `    ``mergeKArrays(arr, i, (i ``+` `j) ``/``/` `2``, out1) ` `    ``mergeKArrays(arr, (i ``+` `j) ``/``/` `2` `+` `1``, j, out2) ` ` `  `    ``# Merge the output array ` `    ``mergeArrays(out1, out2, ` `                ``N ``*` `(((i ``+` `j) ``/` `2``) ``-` `i ``+` `1``), ` `                ``N ``*` `(j ``-` `((i ``+` `j) ``/` `2``)), output) ` ` `  ` `  `# Driver's code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=` `[[``2``, ``6``, ``12``, ``34``], ` `           ``[``1``, ``9``, ``20``, ``1000``], ` `           ``[``23``, ``34``, ``90``, ``2000``]] ` ` `  `    ``K ``=` `len``(arr) ` `    ``output ``=` `[``0` `for` `i ``in` `range``(N ``*` `K)] ` ` `  `    ``# Function call ` `    ``mergeKArrays(arr, ``0``, ``2``, output) ` ` `  `    ``print``(``"Merged array is "``) ` `    ``printArray(output, N ``*` `K) ` ` `  `# This code is contributed by shinjanpatra `

## C#

 `// C# program to merge K sorted arrays of size n each. ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``static` `readonly` `int` `N = 4; ` ` `  `    ``public` `static` `int``[] GetRow(``int``[, ] matrix, ``int` `row) ` `    ``{ ` `        ``var` `rowLength = matrix.GetLength(1); ` `        ``var` `rowVector = ``new` `int``[rowLength]; ` ` `  `        ``for` `(``var` `i = 0; i < rowLength; i++) ` `            ``rowVector[i] = matrix[row, i]; ` ` `  `        ``return` `rowVector; ` `    ``} ` ` `  `    ``// Merge arr1[0..n1-1] and arr2[0..n2-1] into ` `    ``// arr3[0..n1+n2-1] ` `    ``static` `void` `mergeArrays(``int``[] arr1, ``int``[] arr2, ``int` `N1, ` `                            ``int` `N2, ``int``[] arr3) ` `    ``{ ` `        ``int` `i = 0, j = 0, k = 0; ` ` `  `        ``// Traverse both array ` `        ``while` `(i < N1 && j < N2) { ` ` `  `            ``// Check if current element of first ` `            ``// array is smaller than current element ` `            ``// of second array. If yes, store first ` `            ``// array element and increment first array ` `            ``// index. Otherwise do same with second array ` `            ``if` `(arr1[i] < arr2[j]) ` `                ``arr3[k++] = arr1[i++]; ` `            ``else` `                ``arr3[k++] = arr2[j++]; ` `        ``} ` ` `  `        ``// Store remaining elements of first array ` `        ``while` `(i < N1) ` `            ``arr3[k++] = arr1[i++]; ` ` `  `        ``// Store remaining elements of second array ` `        ``while` `(j < N2) ` `            ``arr3[k++] = arr2[j++]; ` `    ``} ` ` `  `    ``// A utility function to print array elements ` `    ``static` `void` `printArray(``int``[] arr, ``int` `size) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < size; i++) ` `            ``Console.Write(arr[i] + ``" "``); ` `    ``} ` ` `  `    ``// This function takes an array of arrays as an ` `    ``// argument and All arrays are assumed to be ` `    ``// sorted. It merges them together and prints ` `    ``// the readonly sorted output. ` `    ``static` `void` `mergeKArrays(``int``[, ] arr, ``int` `i, ``int` `j, ` `                             ``int``[] output) ` `    ``{ ` ` `  `        ``// If one array is in range ` `        ``if` `(i == j) { ` `            ``for` `(``int` `p = 0; p < N; p++) ` `                ``output[p] = arr[i, p]; ` ` `  `            ``return``; ` `        ``} ` ` `  `        ``// If only two arrays are left them merge them ` `        ``if` `(j - i == 1) { ` `            ``mergeArrays(GetRow(arr, i), GetRow(arr, j), N, ` `                        ``N, output); ` `            ``return``; ` `        ``} ` ` `  `        ``// Output arrays ` `        ``int``[] out1 = ``new` `int``[N * (((i + j) / 2) - i + 1)]; ` `        ``int``[] out2 = ``new` `int``[N * (j - ((i + j) / 2))]; ` ` `  `        ``// Divide the array into halves ` `        ``mergeKArrays(arr, i, (i + j) / 2, out1); ` `        ``mergeKArrays(arr, (i + j) / 2 + 1, j, out2); ` ` `  `        ``// Merge the output array ` `        ``mergeArrays(out1, out2, N * (((i + j) / 2) - i + 1), ` `                    ``N * (j - ((i + j) / 2)), output); ` `    ``} ` ` `  `    ``// Driver's code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` ` `  `        ``// Change n at the top to change number of elements ` `        ``// in an array ` `        ``int``[, ] arr = { { 2, 6, 12, 34 }, ` `                        ``{ 1, 9, 20, 1000 }, ` `                        ``{ 23, 34, 90, 2000 } }; ` `        ``int` `K = arr.GetLength(0); ` `        ``int``[] output = ``new` `int``[N * K]; ` ` `  `        ``// Function call ` `        ``mergeKArrays(arr, 0, 2, output); ` ` `  `        ``Console.Write(``"Merged array is "` `                      ``+ ``"\n"``); ` `        ``printArray(output, N * K); ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji`

## Javascript

 `// Javascript program to merge k  ` `// sorted arrays of size n each. ` `let N =  4 ` ` `  `// Merge arr1[0..n1-1] and arr2[0..n2-1] into ` `// arr3[0..n1+n2-1] ` `function` `mergeArrays(arr1, arr2, N1, N2, arr3) ` `{ ` `    ``let i = 0, j = 0, k = 0; ` ` `  `    ``// Traverse both array ` `    ``while` `(i < N1 && j < N2) ` `    ``{ ` `         `  `        ``// Check if current element of first ` `        ``// array is smaller than current element ` `        ``// of second array. If yes, store first ` `        ``// array element and increment first array ` `        ``// index. Otherwise do same with second array ` `        ``if` `(arr1[i] < arr2[j]) ` `            ``arr3[k++] = arr1[i++]; ` `        ``else` `            ``arr3[k++] = arr2[j++]; ` `    ``} ` `     `  `    ``// Store remaining elements of first array ` `    ``while` `(i < N1) ` `        ``arr3[k++] = arr1[i++]; ` ` `  `    ``// Store remaining elements of second array ` `    ``while` `(j < N2) ` `        ``arr3[k++] = arr2[j++]; ` `} ` ` `  `// A utility function to print array elements ` `function` `printArray(arr, size) ` `{ ` `    ``for``(let i = 0; i < size; i++) ` `        ``document.write(arr[i] + ``" "``); ` `} ` ` `  `// This function takes an array of arrays  ` `// as an argument and all arrays are assumed  ` `// to be sorted. It merges them together ` `// and prints the final sorted output. ` `function` `mergeKArrays(arr, i, j, output) ` `{ ` `     `  `    ``// If one array is in range ` `    ``if` `(i == j) ` `    ``{ ` `        ``for``(let p = 0; p < N; p++) ` `            ``output[p] = arr[i][p]; ` `             `  `        ``return``; ` `    ``} ` `     `  `    ``// If only two arrays are left  ` `    ``// them merge them ` `    ``if` `(j - i == 1) ` `    ``{ ` `        ``mergeArrays(arr[i], arr[j], ` `                    ``N, N, output); ` `        ``return``; ` `    ``} ` `     `  `    ``// Output arrays ` `    ``let out1 = ``new` `Array(N * (((i + j) / 2) - i + 1)) ` `    ``let out2 = ``new` `Array(N * (j - ((i + j) / 2))); ` `     `  `    ``// Divide the array into halves ` `    ``mergeKArrays(arr, i, (i + j) / 2, out1); ` `    ``mergeKArrays(arr, (i + j) / 2 + 1, j, out2); ` `     `  `    ``// Merge the output array ` `    ``mergeArrays(out1, out2,  ` `                ``N * (((i + j) / 2) - i + 1), ` `                ``N * (j - ((i + j) / 2)), output); ` `} ` ` `  `// Driver code ` ` `  `// Change n at the top to change number ` `// of elements in an array ` `let arr = [ [ 2, 6, 12, 34 ], ` `            ``[ 1, 9, 20, 1000 ], ` `            ``[ 23, 34, 90, 2000 ] ]; ` `let K = arr.length; ` `let output = ``new` `Array(N * K); ` ` `  `mergeKArrays(arr, 0, 2, output); ` ` `  `document.write(``"Merged array is "` `+ ``"
"``); ` `printArray(output, N * K); ` ` `  `// This code is contributed by Mayank Tyagi`

Output

```Merged array is
1 2 6 9 12 20 23 34 34 90 1000 2000 ```

Time Complexity: O(N * K * log K).  There are log K levels as in each level the K arrays are divided in half and at each level, the K arrays are traversed.
Auxiliary Space: O(N * K * log K). In each level O(N * K) space is required.

## Merge K sorted arrays using Min-Heap:

The idea is to use Min Heap. This MinHeap based solution has the same time complexity which is O(NK log K). But for a different and particular sized array, this solution works much better. The process must start with creating a MinHeap and inserting the first element of all the k arrays. Remove the root element of Minheap and put it in the output array and insert the next element from the array of removed element. To get the result the step must continue until there is no element left in the MinHeap.

Follow the given steps to solve the problem:

• Create a min Heap and insert the first element of all the K arrays.
• Run a loop until the size of MinHeap is greater than zero.
• Remove the top element of the MinHeap and print the element.
• Now insert the next element from the same array in which the removed element belonged.
• If the array doesn’t have any more elements, then replace root with infinite. After replacing the root, heapify the tree.
• Return the output array

Below is the implementation of the above approach:

## C++

 `// C++ program to merge K sorted ` `// arrays of size N each. ` `#include ` `using` `namespace` `std; ` ` `  `#define N 4 ` ` `  `// A min-heap node ` `struct` `MinHeapNode { ` `    ``// The element to be stored ` `    ``int` `element; ` ` `  `    ``// index of the array from which the element is taken ` `    ``int` `i; ` ` `  `    ``// index of the next element to be picked from the array ` `    ``int` `j; ` `}; ` ` `  `// Prototype of a utility function to swap two min-heap ` `// nodes ` `void` `swap(MinHeapNode* x, MinHeapNode* y); ` ` `  `// A class for Min Heap ` `class` `MinHeap { ` ` `  `    ``// pointer to array of elements in heap ` `    ``MinHeapNode* harr; ` ` `  `    ``// size of min heap ` `    ``int` `heap_size; ` ` `  `public``: ` `    ``// Constructor: creates a min heap of given size ` `    ``MinHeap(MinHeapNode a[], ``int` `size); ` ` `  `    ``// to heapify a subtree with root at given index ` `    ``void` `MinHeapify(``int``); ` ` `  `    ``// to get index of left child of node at index i ` `    ``int` `left(``int` `i) { ``return` `(2 * i + 1); } ` ` `  `    ``// to get index of right child of node at index i ` `    ``int` `right(``int` `i) { ``return` `(2 * i + 2); } ` ` `  `    ``// to get the root ` `    ``MinHeapNode getMin() { ``return` `harr[0]; } ` ` `  `    ``// to replace root with new node x and heapify() new ` `    ``// root ` `    ``void` `replaceMin(MinHeapNode x) ` `    ``{ ` `        ``harr[0] = x; ` `        ``MinHeapify(0); ` `    ``} ` `}; ` ` `  `// This function takes an array of arrays as an argument and ` `// All arrays are assumed to be sorted. It merges them ` `// together and prints the final sorted output. ` `int``* mergeKArrays(``int` `arr[][N], ``int` `K) ` `{ ` ` `  `    ``// To store output array ` `    ``int``* output = ``new` `int``[N * K]; ` ` `  `    ``// Create a min heap with k heap nodes. ` `    ``// Every heap node has first element of an array ` `    ``MinHeapNode* harr = ``new` `MinHeapNode[K]; ` `    ``for` `(``int` `i = 0; i < K; i++) { ` ` `  `        ``// Store the first element ` `        ``harr[i].element = arr[i][0]; ` ` `  `        ``// index of array ` `        ``harr[i].i = i; ` ` `  `        ``// Index of next element to be stored from the array ` `        ``harr[i].j = 1; ` `    ``} ` ` `  `    ``// Create the heap ` `    ``MinHeap hp(harr, K); ` ` `  `    ``// Now one by one get the minimum element from min ` `    ``// heap and replace it with next element of its array ` `    ``for` `(``int` `count = 0; count < N * K; count++) { ` `        ``// Get the minimum element and store it in output ` `        ``MinHeapNode root = hp.getMin(); ` `        ``output[count] = root.element; ` ` `  `        ``// Find the next element that will replace current ` `        ``// root of heap. The next element belongs to same ` `        ``// array as the current root. ` `        ``if` `(root.j < N) { ` `            ``root.element = arr[root.i][root.j]; ` `            ``root.j += 1; ` `        ``} ` `        ``// If root was the last element of its array ` `        ``// INT_MAX is for infinite ` `        ``else` `            ``root.element = INT_MAX; ` ` `  `        ``// Replace root with next element of array ` `        ``hp.replaceMin(root); ` `    ``} ` ` `  `    ``return` `output; ` `} ` ` `  `// FOLLOWING ARE IMPLEMENTATIONS OF ` `// STANDARD MIN HEAP METHODS FROM CORMEN BOOK ` `// Constructor: Builds a heap from a given ` `// array a[] of given size ` `MinHeap::MinHeap(MinHeapNode a[], ``int` `size) ` `{ ` `    ``heap_size = size; ` `    ``harr = a; ``// store address of array ` `    ``int` `i = (heap_size - 1) / 2; ` `    ``while` `(i >= 0) { ` `        ``MinHeapify(i); ` `        ``i--; ` `    ``} ` `} ` ` `  `// A recursive method to heapify a ` `// subtree with root at given index. ` `// This method assumes that the subtrees ` `// are already heapified ` `void` `MinHeap::MinHeapify(``int` `i) ` `{ ` `    ``int` `l = left(i); ` `    ``int` `r = right(i); ` `    ``int` `smallest = i; ` ` `  `    ``if` `(l < heap_size && harr[l].element < harr[i].element) ` `        ``smallest = l; ` ` `  `    ``if` `(r < heap_size ` `        ``&& harr[r].element < harr[smallest].element) ` `        ``smallest = r; ` ` `  `    ``if` `(smallest != i) { ` `        ``swap(&harr[i], &harr[smallest]); ` `        ``MinHeapify(smallest); ` `    ``} ` `} ` ` `  `// A utility function to swap two elements ` `void` `swap(MinHeapNode* x, MinHeapNode* y) ` `{ ` `    ``MinHeapNode temp = *x; ` `    ``*x = *y; ` `    ``*y = temp; ` `} ` ` `  `// A utility function to print array elements ` `void` `printArray(``int` `arr[], ``int` `size) ` `{ ` `    ``for` `(``int` `i = 0; i < size; i++) ` `        ``cout << arr[i] << ``" "``; ` `} ` ` `  `// Driver's code ` `int` `main() ` `{ ` `    ``// Change N at the top to change number of elements ` `    ``// in an array ` `    ``int` `arr[][N] = { { 2, 6, 12, 34 }, ` `                     ``{ 1, 9, 20, 1000 }, ` `                     ``{ 23, 34, 90, 2000 } }; ` `    ``int` `K = ``sizeof``(arr) / ``sizeof``(arr[0]); ` ` `  `    ``// Function call ` `    ``int``* output = mergeKArrays(arr, K); ` ` `  `    ``cout << ``"Merged array is "` `<< endl; ` `    ``printArray(output, N * K); ` ` `  `    ``return` `0; ` `}`

## Java

 `// Java program to merge K sorted ` `// arrays of size N each. ` ` `  `// A Min heap node ` `class` `MinHeapNode { ` `    ``int` `element; ``// The element to be stored ` ` `  `    ``// index of the array from ` `    ``// which the element is taken ` `    ``int` `i; ` ` `  `    ``// index of the next element ` `    ``// to be picked from array ` `    ``int` `j; ` ` `  `    ``public` `MinHeapNode(``int` `element, ``int` `i, ``int` `j) ` `    ``{ ` `        ``this``.element = element; ` `        ``this``.i = i; ` `        ``this``.j = j; ` `    ``} ` `}; ` ` `  `// A class for Min Heap ` `class` `MinHeap { ` `    ``MinHeapNode[] harr; ``// Array of elements in heap ` `    ``int` `heap_size; ``// Current number of elements in min heap ` ` `  `    ``// Constructor: Builds a heap from ` `    ``// a given array a[] of given size ` `    ``public` `MinHeap(MinHeapNode a[], ``int` `size) ` `    ``{ ` `        ``heap_size = size; ` `        ``harr = a; ` `        ``int` `i = (heap_size - ``1``) / ``2``; ` `        ``while` `(i >= ``0``) { ` `            ``MinHeapify(i); ` `            ``i--; ` `        ``} ` `    ``} ` ` `  `    ``// A recursive method to heapify a subtree ` `    ``// with the root at given index This method ` `    ``// assumes that the subtrees are already heapified ` `    ``void` `MinHeapify(``int` `i) ` `    ``{ ` `        ``int` `l = left(i); ` `        ``int` `r = right(i); ` `        ``int` `smallest = i; ` ` `  `        ``if` `(l < heap_size ` `            ``&& harr[l].element < harr[i].element) ` `            ``smallest = l; ` ` `  `        ``if` `(r < heap_size ` `            ``&& harr[r].element < harr[smallest].element) ` `            ``smallest = r; ` ` `  `        ``if` `(smallest != i) { ` `            ``swap(harr, i, smallest); ` `            ``MinHeapify(smallest); ` `        ``} ` `    ``} ` ` `  `    ``// to get index of left child of node at index i ` `    ``int` `left(``int` `i) { ``return` `(``2` `* i + ``1``); } ` ` `  `    ``// to get index of right child of node at index i ` `    ``int` `right(``int` `i) { ``return` `(``2` `* i + ``2``); } ` ` `  `    ``// to get the root ` `    ``MinHeapNode getMin() ` `    ``{ ` `        ``if` `(heap_size <= ``0``) { ` `            ``System.out.println(``"Heap underflow"``); ` `            ``return` `null``; ` `        ``} ` `        ``return` `harr[``0``]; ` `    ``} ` ` `  `    ``// to replace root with new node ` `    ``// "root" and heapify() new root ` `    ``void` `replaceMin(MinHeapNode root) ` `    ``{ ` `        ``harr[``0``] = root; ` `        ``MinHeapify(``0``); ` `    ``} ` ` `  `    ``// A utility function to swap two min heap nodes ` `    ``void` `swap(MinHeapNode[] arr, ``int` `i, ``int` `j) ` `    ``{ ` `        ``MinHeapNode temp = arr[i]; ` `        ``arr[i] = arr[j]; ` `        ``arr[j] = temp; ` `    ``} ` ` `  `    ``// A utility function to print array elements ` `    ``static` `void` `printArray(``int``[] arr) ` `    ``{ ` `        ``for` `(``int` `i : arr) ` `            ``System.out.print(i + ``" "``); ` `        ``System.out.println(); ` `    ``} ` ` `  `    ``// This function takes an array of ` `    ``// arrays as an argument and All ` `    ``// arrays are assumed to be sorted. ` `    ``// It merges them together and ` `    ``// prints the final sorted output. ` `    ``static` `void` `mergeKSortedArrays(``int``[][] arr, ``int` `K) ` `    ``{ ` `        ``MinHeapNode[] hArr = ``new` `MinHeapNode[K]; ` `        ``int` `resultSize = ``0``; ` `        ``for` `(``int` `i = ``0``; i < arr.length; i++) { ` `            ``MinHeapNode node ` `                ``= ``new` `MinHeapNode(arr[i][``0``], i, ``1``); ` `            ``hArr[i] = node; ` `            ``resultSize += arr[i].length; ` `        ``} ` ` `  `        ``// Create a min heap with k heap nodes. Every heap ` `        ``// node has first element of an array ` `        ``MinHeap mh = ``new` `MinHeap(hArr, K); ` ` `  `        ``int``[] result ` `            ``= ``new` `int``[resultSize]; ``// To store output array ` ` `  `        ``// Now one by one get the minimum element from min ` `        ``// heap and replace it with next element of its ` `        ``// array ` `        ``for` `(``int` `i = ``0``; i < resultSize; i++) { ` ` `  `            ``// Get the minimum element and store it in ` `            ``// result ` `            ``MinHeapNode root = mh.getMin(); ` `            ``result[i] = root.element; ` ` `  `            ``// Find the next element that will replace ` `            ``// current root of heap. The next element ` `            ``// belongs to same array as the current root. ` `            ``if` `(root.j < arr[root.i].length) ` `                ``root.element = arr[root.i][root.j++]; ` `            ``// If root was the last element of its array ` `            ``else` `                ``root.element = Integer.MAX_VALUE; ` ` `  `            ``// Replace root with next element of array ` `            ``mh.replaceMin(root); ` `        ``} ` ` `  `        ``printArray(result); ` `    ``} ` ` `  `    ``// Driver's code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int``[][] arr = { { ``2``, ``6``, ``12``, ``34` `}, ` `                        ``{ ``1``, ``9``, ``20``, ``1000` `}, ` `                        ``{ ``23``, ``34``, ``90``, ``2000` `} }; ` ` `  `        ``System.out.println(``"Merged array is :"``); ` ` `  `        ``// Function call ` `        ``mergeKSortedArrays(arr, arr.length); ` `    ``} ` `}; ` ` `  `// This code is contributed by shubham96301`

## Python3

 `import` `sys ` ` `  `# Python 3 program to merge K sorted ` `# arrays of size N each. ` `# A Min heap node ` `class` `MinHeapNode : ` `    ``element ``=` `0` `     `  `    ``# The element to be stored ` `    ``# index of the array from ` `    ``# which the element is taken ` `    ``i ``=` `0` `     `  `    ``# index of the next element ` `    ``# to be picked from array ` `    ``j ``=` `0` `    ``def` `__init__(``self``, element,  i,  j) : ` `        ``self``.element ``=` `element ` `        ``self``.i ``=` `i ` `        ``self``.j ``=` `j ` `         `  `# A class for Min Heap ` `class` `MinHeap : ` `    ``harr ``=` `None` `     `  `    ``# Array of elements in heap ` `    ``heap_size ``=` `0` `     `  `    ``# Current number of elements in min heap ` `    ``# Constructor: Builds a heap from ` `    ``# a given array a[] of given size ` `    ``def` `__init__(``self``, a,  size) : ` `        ``self``.heap_size ``=` `size ` `        ``self``.harr ``=` `a ` `        ``i ``=` `int``((``self``.heap_size ``-` `1``) ``/` `2``) ` `        ``while` `(i >``=` `0``) : ` `            ``self``.MinHeapify(i) ` `            ``i ``-``=` `1` `             `  `    ``# A recursive method to heapify a subtree ` `    ``# with the root at given index This method ` `    ``# assumes that the subtrees are already heapified ` `    ``def` `MinHeapify(``self``, i) : ` `        ``l ``=` `self``.left(i) ` `        ``r ``=` `self``.right(i) ` `        ``smallest ``=` `i ` `        ``if` `(l < ``self``.heap_size ``and` `self``.harr[l].element < ``self``.harr[i].element) : ` `            ``smallest ``=` `l ` `        ``if` `(r < ``self``.heap_size ``and` `self``.harr[r].element < ``self``.harr[smallest].element) : ` `            ``smallest ``=` `r ` `        ``if` `(smallest !``=` `i) : ` `            ``self``.swap(``self``.harr, i, smallest) ` `            ``self``.MinHeapify(smallest) ` `             `  `    ``# to get index of left child of node at index i ` `    ``def`  `left(``self``, i) : ` `        ``return` `(``2` `*` `i ``+` `1``) ` `       `  `    ``# to get index of right child of node at index i ` `    ``def`  `right(``self``, i) : ` `        ``return` `(``2` `*` `i ``+` `2``) ` `       `  `    ``# to get the root ` `    ``def`  `getMin(``self``) : ` `        ``if` `(``self``.heap_size <``=` `0``) : ` `            ``print``(``"Heap underflow"``) ` `            ``return` `None` `        ``return` `self``.harr[``0``] ` `       `  `    ``# to replace root with new node ` `    ``# "root" and heapify() new root ` `    ``def` `replaceMin(``self``, root) : ` `        ``self``.harr[``0``] ``=` `root ` `        ``self``.MinHeapify(``0``) ` `         `  `    ``# A utility function to swap two min heap nodes ` `    ``def` `swap(``self``, arr,  i,  j) : ` `        ``temp ``=` `arr[i] ` `        ``arr[i] ``=` `arr[j] ` `        ``arr[j] ``=` `temp ` `         `  `    ``# A utility function to print array elements ` `    ``@staticmethod` `    ``def` `printArray( arr) : ` `        ``for` `i ``in` `arr : ` `            ``print``(``str``(i) ``+` `" "``, end ``=``"") ` `        ``print``() ` `         `  `    ``# This function takes an array of ` `    ``# arrays as an argument and All ` `    ``# arrays are assumed to be sorted. ` `    ``# It merges them together and ` `    ``# prints the final sorted output. ` `    ``@staticmethod` `    ``def` `mergeKSortedArrays( arr,  K) : ` `        ``hArr ``=` `[``None``] ``*` `(K) ` `        ``resultSize ``=` `0` `        ``i ``=` `0` `        ``while` `(i < ``len``(arr)) : ` `            ``node ``=` `MinHeapNode(arr[i][``0``], i, ``1``) ` `            ``hArr[i] ``=` `node ` `            ``resultSize ``+``=` `len``(arr[i]) ` `            ``i ``+``=` `1` `             `  `        ``# Create a min heap with k heap nodes. Every heap ` `        ``# node has first element of an array ` `        ``mh ``=` `MinHeap(hArr, K) ` `        ``result ``=` `[``0``] ``*` `(resultSize) ` `         `  `        ``# To store output array ` `        ``# Now one by one get the minimum element from min ` `        ``# heap and replace it with next element of its ` `        ``# array ` `        ``i ``=` `0` `        ``while` `(i < resultSize) : ` `           `  `            ``# Get the minimum element and store it in ` `            ``# result ` `            ``root ``=` `mh.getMin() ` `            ``result[i] ``=` `root.element ` `             `  `            ``# Find the next element that will replace ` `            ``# current root of heap. The next element ` `            ``# belongs to same array as the current root. ` `            ``if` `(root.j < ``len``(arr[root.i])) : ` `                ``root.element ``=` `arr[root.i][root.j] ` `                ``root.j ``+``=` `1` `            ``else` `: ` `                ``root.element ``=` `sys.maxsize ` `                 `  `            ``# Replace root with next element of array ` `            ``mh.replaceMin(root) ` `            ``i ``+``=` `1` `        ``MinHeap.printArray(result) ` `         `  `    ``# Driver's code ` `    ``@staticmethod` `    ``def` `main( args) : ` `        ``arr ``=` `[[``2``, ``6``, ``12``, ``34``], [``1``, ``9``, ``20``, ``1000``], [``23``, ``34``, ``90``, ``2000``]] ` `        ``print``(``"Merged array is :"``) ` `        ``# Function call ` `        ``MinHeap.mergeKSortedArrays(arr, ``len``(arr)) ` `     `  `if` `__name__``=``=``"__main__"``: ` `    ``MinHeap.main([]) ` `     `  `    ``# This code is contributed by aadityaburujwale.`

## C#

 `// C# program to merge K sorted ` `// arrays of size N each. ` ` `  `using` `System; ` ` `  `// A Min heap node ` `public` `class` `MinHeapNode { ` `    ``public` `int` `element; ``// The element to be stored ` ` `  `    ``// index of the array from ` `    ``// which the element is taken ` `    ``public` `int` `i; ` ` `  `    ``// index of the next element ` `    ``// to be picked from array ` `    ``public` `int` `j; ` ` `  `    ``public` `MinHeapNode(``int` `element, ``int` `i, ``int` `j) ` `    ``{ ` `        ``this``.element = element; ` `        ``this``.i = i; ` `        ``this``.j = j; ` `    ``} ` `}; ` ` `  `// A class for Min Heap ` `public` `class` `MinHeap { ` `    ``MinHeapNode[] harr; ``// Array of elements in heap ` `    ``int` `heap_size; ``// Current number of elements in min heap ` ` `  `    ``// Constructor: Builds a heap from ` `    ``// a given array a[] of given size ` `    ``public` `MinHeap(MinHeapNode[] a, ``int` `size) ` `    ``{ ` `        ``heap_size = size; ` `        ``harr = a; ` `        ``int` `i = (heap_size - 1) / 2; ` `        ``while` `(i >= 0) { ` `            ``MinHeapify(i); ` `            ``i--; ` `        ``} ` `    ``} ` ` `  `    ``// A recursive method to heapify a subtree ` `    ``// with the root at given index This method ` `    ``// assumes that the subtrees are already heapified ` `    ``void` `MinHeapify(``int` `i) ` `    ``{ ` `        ``int` `l = left(i); ` `        ``int` `r = right(i); ` `        ``int` `smallest = i; ` ` `  `        ``if` `(l < heap_size ` `            ``&& harr[l].element < harr[i].element) ` `            ``smallest = l; ` ` `  `        ``if` `(r < heap_size ` `            ``&& harr[r].element < harr[smallest].element) ` `            ``smallest = r; ` ` `  `        ``if` `(smallest != i) { ` `            ``swap(harr, i, smallest); ` `            ``MinHeapify(smallest); ` `        ``} ` `    ``} ` ` `  `    ``// to get index of left child of node at index i ` `    ``int` `left(``int` `i) { ``return` `(2 * i + 1); } ` ` `  `    ``// to get index of right child of node at index i ` `    ``int` `right(``int` `i) { ``return` `(2 * i + 2); } ` ` `  `    ``// to get the root ` `    ``MinHeapNode getMin() ` `    ``{ ` `        ``if` `(heap_size <= 0) { ` `            ``Console.WriteLine(``"Heap underflow"``); ` `            ``return` `null``; ` `        ``} ` `        ``return` `harr[0]; ` `    ``} ` ` `  `    ``// to replace root with new node ` `    ``// "root" and heapify() new root ` `    ``void` `replaceMin(MinHeapNode root) ` `    ``{ ` `        ``harr[0] = root; ` `        ``MinHeapify(0); ` `    ``} ` ` `  `    ``// A utility function to swap two min heap nodes ` `    ``void` `swap(MinHeapNode[] arr, ``int` `i, ``int` `j) ` `    ``{ ` `        ``MinHeapNode temp = arr[i]; ` `        ``arr[i] = arr[j]; ` `        ``arr[j] = temp; ` `    ``} ` ` `  `    ``// A utility function to print array elements ` `    ``static` `void` `printArray(``int``[] arr) ` `    ``{ ` `        ``foreach``(``int` `i ``in` `arr) Console.Write(i + ``" "``); ` `        ``Console.WriteLine(); ` `    ``} ` ` `  `    ``// This function takes an array of ` `    ``// arrays as an argument and All ` `    ``// arrays are assumed to be sorted. ` `    ``// It merges them together and ` `    ``// prints the final sorted output. ` `    ``static` `void` `mergeKSortedArrays(``int``[, ] arr, ``int` `K) ` `    ``{ ` `        ``MinHeapNode[] hArr = ``new` `MinHeapNode[K]; ` `        ``int` `resultSize = 0; ` `        ``for` `(``int` `i = 0; i < arr.GetLength(0); i++) { ` `            ``MinHeapNode node ` `                ``= ``new` `MinHeapNode(arr[i, 0], i, 1); ` `            ``hArr[i] = node; ` `            ``resultSize += arr.GetLength(1); ` `        ``} ` ` `  `        ``// Create a min heap with k heap nodes. ` `        ``// Every heap node has first element of an array ` `        ``MinHeap mh = ``new` `MinHeap(hArr, K); ` ` `  `        ``int``[] result ` `            ``= ``new` `int``[resultSize]; ``// To store output array ` ` `  `        ``// Now one by one get the minimum element ` `        ``// from min heap and replace it with ` `        ``// next element of its array ` `        ``for` `(``int` `i = 0; i < resultSize; i++) { ` ` `  `            ``// Get the minimum element and ` `            ``// store it in result ` `            ``MinHeapNode root = mh.getMin(); ` `            ``result[i] = root.element; ` ` `  `            ``// Find the next element that will ` `            ``// replace current root of heap. ` `            ``// The next element belongs to same ` `            ``// array as the current root. ` `            ``if` `(root.j < arr.GetLength(1)) ` `                ``root.element = arr[root.i, root.j++]; ` ` `  `            ``// If root was the last element of its array ` `            ``else` `                ``root.element = ``int``.MaxValue; ` ` `  `            ``// Replace root with next element of array ` `            ``mh.replaceMin(root); ` `        ``} ` `        ``printArray(result); ` `    ``} ` ` `  `    ``// Driver's code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int``[, ] arr = { { 2, 6, 12, 34 }, ` `                        ``{ 1, 9, 20, 1000 }, ` `                        ``{ 23, 34, 90, 2000 } }; ` ` `  `        ``Console.WriteLine(``"Merged array is :"``); ` ` `  `        ``// Function call ` `        ``mergeKSortedArrays(arr, arr.GetLength(0)); ` `    ``} ` `}; ` ` `  `// This code is contributed by 29AjayKumar`

## Javascript

 `function` `countPaths(n, m, k, a) { ` `  ``// cnt1: number of steps in left part ` `  ``// cnt2: number of steps in right part ` `  ``let cnt1 = Math.floor((n + m - 2) / 2); ` `  ``let cnt2 = (n + m - 2) - cnt1; ` `   `  `  ``// Edge case: matrix is 1x1 and the only element is k ` `  ``if` `(n === 1 && m === 1 && a[0][0] === k) { ` `    ``return` `1; ` `  ``} ` ` `  `  ``const mp1 = {}; ``// left part ` `  ``const mp2 = {}; ``// right part ` ` `  `  ``// Recursive function for left part ` `  ``function` `part1(i, j, cnt, zor) { ` `    ``if` `(cnt <= 0) { ` `      ``// Count the number of triplets ` `      ``if` `(!mp1[zor]) { ` `        ``mp1[zor] = {}; ` `      ``} ` `      ``if` `(!mp1[zor][i]) { ` `        ``mp1[zor][i] = {}; ` `      ``} ` `      ``if` `(!mp1[zor][i][j]) { ` `        ``mp1[zor][i][j] = 0; ` `      ``} ` `      ``mp1[zor][i][j]++; ` `      ``return``; ` `    ``} ` `     `  `    ``// Move rightwards ` `    ``if` `(j + 1 < m) { ` `      ``part1(i, j + 1, cnt - 1, zor ^ a[i][j + 1]); ` `    ``} ` `     `  `    ``// Move downwards ` `    ``if` `(i + 1 < n) { ` `      ``part1(i + 1, j, cnt - 1, zor ^ a[i + 1][j]); ` `    ``} ` `  ``} ` ` `  `  ``// Recursive function for right part ` `  ``function` `part2(i, j, cnt, zor) { ` `    ``if` `(cnt <= 0) { ` `      ``// Count the number of triplets ` `      ``if` `(!mp2[zor]) { ` `        ``mp2[zor] = {}; ` `      ``} ` `      ``if` `(!mp2[zor][i]) { ` `        ``mp2[zor][i] = {}; ` `      ``} ` `      ``if` `(!mp2[zor][i][j]) { ` `        ``mp2[zor][i][j] = 0; ` `      ``} ` `      ``mp2[zor][i][j]++; ` `      ``return``; ` `    ``} ` `     `  `    ``// Move leftwards ` `    ``if` `(j - 1 >= 0) { ` `      ``part2(i, j - 1, cnt - 1, zor ^ a[i][j - 1]); ` `    ``} ` `     `  `    ``// Move upwards ` `    ``if` `(i - 1 >= 0) { ` `      ``part2(i - 1, j, cnt - 1, zor ^ a[i - 1][j]); ` `    ``} ` `  ``} ` ` `  `  ``// Call the recursive functions for left and right parts ` `  ``part1(0, 0, cnt1, a[0][0]); ` `  ``part2(n - 1, m - 1, cnt2 - 1, a[n - 1][m - 1]); ` ` `  `  ``let ans = 0; ` `  ``// Iterate through the triplets in the right part ` `  ``for` `(const zor ``in` `mp2) { ` `    ``for` `(const i ``in` `mp `

Output

```Merged array is
1 2 6 9 12 20 23 34 34 90 1000 2000 ```

Time Complexity: O(N * K * log K), Insertion and deletion in a Min Heap requires log K time.
Auxiliary Space: O(K), If Output is not stored then the only space required is the Min-Heap of K elements.

Merge k sorted arrays | Set 2 (Different Sized Arrays)

My Personal Notes arrow_drop_up
Related Articles