Merge Three Sorted strings

Question

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

Codemia · Accepted Answer

To solve the problem of merging k sorted strings, we can leverage a min-heap (or priority queue) which allows us to efficiently extract the smallest element among the current leading elements of each sorted string. This approach is suitable because it efficiently manages the order of elements as we merge the strings while maintaining overall sorting. This is a direct application of the 'k-way merge' algorithm, commonly used in merging multiple sorted lists.

1. **Initialize a min-heap**: Create a priority queue to store the characters from the three strings. 
2. **Insert the first character of each string**: For each of the three strings, if it is not empty, insert the first character along with its respective string index into the heap. 
3. **Merge the strings**: While the heap is not empty, extract the smallest character, add it to the result string, and if the extracted character has a next character in its respective string, push that next character into the heap. 
4. **Continue until all characters are processed**.

**Example**: Given strings: `s1 = 'abc'`, `s2 = 'ac'`, `s3 = 'b'`. 
- Initially, insert characters: `a (from s1), a (from s2), b (from s3)` into the heap. 
- Extract `a`, add to result: `result = 'a'`, push next character from `s1` -> `result = 'a', b (from s3), c (from s1)`. 
- Repeat until all characters are processed.

```python
import heapq

def merge_sorted_strings(s1, s2, s3):
    min_heap = []
    result = ''

# Insert the first character of each string into the heap
    if s1: heapq.heappush(min_heap, (s1[0], 0, s1))
    if s2: heapq.heappush(min_heap, (s2[0], 0, s2))
    if s3: heapq.heappush(min_heap, (s3[0], 0, s3))

while min_heap:
        char, index, source = heapq.heappop(min_heap)
        result += char
        if index + 1 < len(source):
            heapq.heappush(min_heap, (source[index + 1], index + 1, source))

return result
```

The time complexity of this approach is O(n log k), where n is the total number of characters across the three strings and k is the number of strings (which is 3 in this case). The log k factor comes from the operations on the heap. The space complexity is O(k) due to the storage of characters in the heap.

1. **All strings empty**: If all input strings are empty (`s1 = '', s2 = '', s3 = ''`), the result should be an empty string. 
2. **One string empty**: If one string is empty, for example, `s1 = 'abc', s2 = '', s3 = 'de'`, the merged result should be `abcde`. 
3. **Strings of varying lengths**: Handling strings of different lengths is accounted for as the algorithm continues until all characters are processed. 
4. **Single character strings**: If all strings contain a single character, e.g., `s1 = 'a', s2 = 'b', s3 = 'c'`, the result should be 'abc'.

Merge Three Sorted strings

Doordash

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

Doordash 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