Add MergeKSortedArrays algorithm (#5838)

src/main/java/com/thealgorithms/datastructures/heaps/MergeKSortedArrays.java

@@ -0,0 +1,60 @@
+package com.thealgorithms.datastructures.heaps;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+/**
+ * This class provides a method to merge multiple sorted arrays into a single sorted array.
+ * It utilizes a min-heap to efficiently retrieve the smallest elements from each array.
+ *
+ * Time Complexity: O(n * log k), where n is the total number of elements across all arrays
+ * and k is the number of arrays.
+ *
+ * Space Complexity: O(k) for the heap, where k is the number of arrays.
+ *
+ * @author Hardvan
+ */
+public final class MergeKSortedArrays {
+    private MergeKSortedArrays() {
+    }
+
+    /**
+     * Merges k sorted arrays into one sorted array using a min-heap.
+     * Steps:
+     * 1. Create a min-heap to store elements in the format: {value, array index, element index}
+     * 2. Add the first element from each array to the heap
+     * 3. While the heap is not empty, remove the smallest element from the heap
+     *   and add it to the result array. If there are more elements in the same array,
+     *   add the next element to the heap.
+     *   Continue until all elements have been processed.
+     *   The result array will contain all elements in sorted order.
+     * 4. Return the result array.
+     *
+     * @param arrays a 2D array, where each subarray is sorted in non-decreasing order
+     * @return a single sorted array containing all elements from the input arrays
+     */
+    public static int[] mergeKArrays(int[][] arrays) {
+        PriorityQueue<int[]> minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+
+        int totalLength = 0;
+        for (int i = 0; i < arrays.length; i++) {
+            if (arrays[i].length > 0) {
+                minHeap.offer(new int[] {arrays[i][0], i, 0});
+                totalLength += arrays[i].length;
+            }
+        }
+
+        int[] result = new int[totalLength];
+        int index = 0;
+        while (!minHeap.isEmpty()) {
+            int[] top = minHeap.poll();
+            result[index++] = top[0];
+
+            if (top[2] + 1 < arrays[top[1]].length) {
+                minHeap.offer(new int[] {arrays[top[1]][top[2] + 1], top[1], top[2] + 1});
+            }
+        }
+
+        return result;
+    }
+}