Merge two sorted arrays in O(n + m) time using Python

Given two sorted arrays of integers, merge them into one sorted array containing all numbers

Example:

Input: first =[1, 4, 8],
       second = [1, 3, 4, 17]

Output: [1, 1, 3, 4, 4, 8, 17]

Note:

Your algorithm should run in O(n + m) time and use O(n + m) extra space.

Understanding the Problem

The core challenge of this problem is to merge two already sorted arrays into a single sorted array efficiently. This problem is significant in various applications such as merging data from different sources, combining search results, and in algorithms like merge sort.

Potential pitfalls include not maintaining the sorted order or using inefficient methods that exceed the desired time complexity.

Approach

To solve this problem, we can use a two-pointer technique. This approach is efficient and ensures that we maintain the sorted order while merging the arrays.

Here’s a step-by-step approach:

Initialize two pointers, one for each array.
Compare the elements at the pointers and append the smaller element to the result array.
Move the pointer of the array from which the element was taken.
Repeat the process until one of the arrays is exhausted.
Append the remaining elements of the non-exhausted array to the result array.

Algorithm

Let's break down the algorithm step-by-step:

Initialize two pointers, i and j, to 0.
Create an empty list merged to store the result.
While both pointers are within the bounds of their respective arrays:
- Compare first[i] and second[j].
- Append the smaller value to merged.
- Increment the pointer of the array from which the smaller value was taken.
Once one of the arrays is exhausted, append the remaining elements of the other array to merged.

Code Implementation

def merge_sorted_arrays(first, second):
    # Initialize pointers for both arrays
    i, j = 0, 0
    merged = []

    # Traverse both arrays
    while i < len(first) and j < len(second):
        if first[i] < second[j]:
            merged.append(first[i])
            i += 1
        else:
            merged.append(second[j])
            j += 1

    # If there are remaining elements in the first array
    while i < len(first):
        merged.append(first[i])
        i += 1

    # If there are remaining elements in the second array
    while j < len(second):
        merged.append(second[j])
        j += 1

    return merged

# Example usage
first = [1, 4, 8]
second = [1, 3, 4, 17]
print(merge_sorted_arrays(first, second))  # Output: [1, 1, 3, 4, 4, 8, 17]

Complexity Analysis

The time complexity of this approach is O(n + m) because we traverse each array once. The space complexity is also O(n + m) due to the additional space required for the merged array.

Edge Cases

Consider the following edge cases:

One or both arrays are empty.
Arrays contain duplicate elements.
Arrays of different lengths.

Our algorithm handles these cases effectively by ensuring all elements are considered and merged appropriately.

Testing

To test the solution comprehensively, consider the following test cases:

def test_merge_sorted_arrays():
    assert merge_sorted_arrays([], []) == []
    assert merge_sorted_arrays([1], []) == [1]
    assert merge_sorted_arrays([], [1]) == [1]
    assert merge_sorted_arrays([1, 3, 5], [2, 4, 6]) == [1, 2, 3, 4, 5, 6]
    assert merge_sorted_arrays([1, 2, 3], [4, 5, 6]) == [1, 2, 3, 4, 5, 6]
    assert merge_sorted_arrays([4, 5, 6], [1, 2, 3]) == [1, 2, 3, 4, 5, 6]
    assert merge_sorted_arrays([1, 4, 8], [1, 3, 4, 17]) == [1, 1, 3, 4, 4, 8, 17]

test_merge_sorted_arrays()
print("All tests passed.")

Thinking and Problem-Solving Tips

When approaching such problems, consider the following tips:

Understand the problem requirements and constraints thoroughly.
Break down the problem into smaller, manageable parts.
Consider edge cases and how your solution handles them.
Practice similar problems to improve your problem-solving skills.

Conclusion

In this blog post, we discussed how to merge two sorted arrays efficiently using a two-pointer technique. We covered the problem definition, approach, algorithm, code implementation, complexity analysis, edge cases, and testing. Understanding and solving such problems is crucial for improving your algorithmic thinking and coding skills.

Additional Resources

For further reading and practice, consider the following resources: