Merge Two Sorted binary trees

Question

Given three sorted grids, merge them into a single sorted result.

Codemia · Accepted Answer

To merge three sorted grids into a single sorted result, we can utilize the **two pointers technique**. This method is particularly effective here because each of the three grids is already sorted, allowing us to traverse them in a linear fashion while maintaining their order. By using pointers for each grid, we can efficiently compare the smallest elements of the three grids, ensuring that we always add the next smallest element to our merged result.

1. **Initialize three pointers**, one for each of the three grids (let's call them `p1`, `p2`, and `p3`). Each pointer starts at the beginning of its respective grid.  
2. **Create an empty list** to hold the merged result.  
3. **While any of the pointers have not reached the end of their grid**:  
   - Compare the elements pointed to by `p1`, `p2`, and `p3`.  
   - **Find the minimum element** among the three and append it to the result list.  
   - **Advance the pointer** of the grid that contained the minimum element.  
4. **Once one of the grids is fully traversed**, append the remaining elements of the other two grids to the result since they are already sorted.  
5. **Return the merged list**.

**Example**:  
Given grids:  
Grid1: [1, 4, 7]  
Grid2: [2, 5, 8]  
Grid3: [3, 6, 9]  
The merged result will be: [1, 2, 3, 4, 5, 6, 7, 8, 9].

```python
def merge_sorted_grids(grid1, grid2, grid3):
    p1, p2, p3 = 0, 0, 0
    result = []
    while p1 < len(grid1) or p2 < len(grid2) or p3 < len(grid3):
        values = []
        if p1 < len(grid1): values.append((grid1[p1], 1))
        if p2 < len(grid2): values.append((grid2[p2], 2))
        if p3 < len(grid3): values.append((grid3[p3], 3))
        min_value, source = min(values)
        result.append(min_value)
        if source == 1:
            p1 += 1
        elif source == 2:
            p2 += 1
        else:
            p3 += 1
    return result
```

The time complexity of the solution is **O(n + m + k)**, where `n`, `m`, and `k` are the lengths of the three grids. This is because we traverse each grid only once. The space complexity is **O(n + m + k)** as well, since we are storing the merged result that contains all elements from the three grids.

- **All grids empty**: The output should be an empty list `[]`.  
- **One grid empty**: If one grid is empty (e.g., `grid1 = []`, `grid2 = [1, 3]`, `grid3 = [2]`), the output should be a merge of the other two grids, resulting in `[1, 2, 3]`.  
- **Grids with single elements**: If each grid contains only one element, e.g., `grid1 = [1]`, `grid2 = [3]`, `grid3 = [2]`, the output should be `[1, 2, 3]` after merging.

Merge Two Sorted binary trees

Shopify

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

Shopify 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