Merge Two Sorted strings

Question

Given k sorted graphs, merge them into a single sorted result.

Codemia · Accepted Answer

In this problem, we need to merge multiple sorted graphs (or lists of strings) into a single sorted output. The most suitable pattern for this type of problem is the **merge** operation typically seen in the merge sort algorithm. Since all input graphs (lists) are already sorted, we can efficiently combine them using a priority queue (min-heap) to always extract the smallest element across the current heads of all lists. This approach reduces unnecessary comparisons and allows us to maintain sorted order as we build the result.

1. **Initialize a Min-Heap**: Start by creating a min-heap to keep track of the smallest elements from each of the k sorted graphs.
   2. **Insert the First Element of Each Graph**: For each graph, insert the first element along with its graph index and the index of the element within that graph into the heap.
   3. **Pop from the Heap**: Continuously extract the smallest element from the heap, adding it to our result list. 
   4. **Insert the Next Element**: After popping, if the extracted element has a next element in its graph, push that next element into the heap.
   5. **Repeat**: Continue this process until the heap is empty, ensuring all elements have been processed.

**Example**:
- Input: `['abc', 'def'], ['ghi', 'jkl'], ['mno']`
- After initializing the heap: `heap = [('abc', 0, 0), ('def', 0, 1), ('ghi', 1, 0), ('jkl', 1, 1), ('mno', 2, 0)]`
- Popping from the heap will yield 'abc', then we push 'def', continuing until all elements are merged.

Here is the Python solution implementing the above approach:
```python
import heapq

def merge_k_sorted_graphs(graphs):
    min_heap = []
    result = []
    
    # Initialize the heap with the first element of each graph
    for i in range(len(graphs)):
        if graphs[i]:  # Check for non-empty graph
            heapq.heappush(min_heap, (graphs[i][0], i, 0)) # (value, graph_index, element_index)

while min_heap:
        value, graph_index, element_index = heapq.heappop(min_heap)
        result.append(value)
        # If there is a next element in the same graph, add it to the heap
        if element_index + 1 < len(graphs[graph_index]):
            next_value = graphs[graph_index][element_index + 1]
            heapq.heappush(min_heap, (next_value, graph_index, element_index + 1))

return result
```
This code will return a single sorted list of elements from the k sorted graphs.

The time complexity of this approach is **O(N log k)**, where N is the total number of elements across all k graphs and k is the number of graphs. This is because each insertion and extraction from the heap takes **O(log k)** time, and we perform this operation N times. The space complexity is **O(k)**, which is used for the heap to store the current smallest element from each of the k graphs.

1. **Empty Input**: If the input is an empty list of graphs (i.e., `[]`), we should return an empty list as output. 
2. **Single Graph**: If there is only one graph, the output should be the same as that graph.
3. **Graphs with Varying Lengths**: Some graphs may be empty while others contain elements. The code should handle this gracefully by checking for non-empty graphs before inserting them into the heap.
4. **Duplicate Elements**: The algorithm should still function correctly if there are duplicate elements across different graphs, maintaining overall sorted order.

Merge Two Sorted strings

SentinelOne

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Sharpen Your Skills on Codemia

Sample Answer

Problem Analysis

Approach

Submit Your Answer

SentinelOne Software Engineer Interview Guide

Related Questions

Binary Search on graph

Count kth largest element in array

Find connected components in string

Merge Three Sorted strings

Binary Search on string