将两个已排序的 arrays 合并为更大的排序数组的时间复杂度是多少？

Question

The code below is my solution to the following problem:

Given 2 arrays of integers sorted in ascending order, write a function that merges those two arrays into one larger sorted array. For example, given the arrays arr1 = [[0, 3, 4, 31] and arr2 = [4, 6, 30] , the solution function should return the array [0, 3, 4, 4, 6, 30, 31] .

My solution:

function mergeSortedArrays(arr1, arr2) {
    // Check input
    if (arr1.length === 0 && arr2.length === 0) {
        return arr1;
    } else if (arr1.length === 0) {
        return arr2;
    } else if (arr2.length === 0) {
        return arr1;
    }

    // Initialize variables
    let i = 0, j = 0;
    const mergedArray = [];

    // Loop through & compare
    while (i < arr1.length && j < arr2.length) {
        if (arr1[i] <= arr2[j]) {
            mergedArray.push(arr1[i]);
            i++;
        } else {
            mergedArray.push(arr2[j]);
            j++;
        }
    }

    if (j < arr2.length) {
        while (j < arr2.length) {
            mergedArray.push(arr2[j]);
            j++;
        }
    } else if (i < arr1.length) {
        while (i < arr1.length) {
            mergedArray.push(arr1[i]);
            i++;
        }
    }

    return mergedArray; // O(1)
}

The solution above works fine. However, I'm having some trouble analyzing the worst-case time complexity of the algorithm I've used. At first glance, it appears to have linear time complexity, O(n), but upon further inspection, the number of iterations in the first loop that compares elements between the two arrays is not exactly bound simply by the length of either of the two arrays. More specifically, it appears to be related to the upper and lower bounds of each array.

TLDR: What is the time complexity of the function above?

Answer 1

O(m+n) where m and n are size of respective arrays.

Answer 2

Time complexity for this algorithm will be O(arr1.length + arr2.length) since effectively we are iterating both the arrays once.

Answer 3

inside the first while loop, on every iteration, you will have either i or j being incremented. The maximum amount of times the while loop can be run is (arr.length - 1) + (arr2.length - 1), as any more will break out of the testing conditions.

Lets call the final state of i and j here as k and l, where either k or l will be equal to their respective upperbounds, and the other will be strictly smaller than their upper bounds. This means this while loop has run k + l times

After the loop, you are performing another two mutually exclusive while loops, each of which starts at k/l stopped at until it reaches it's upper bound. That means the two loops will run (arr.length - k) or (arr2.length - l) times.

So the final results you have run is first while loop: (k + l) + second sets of loops:

   if k != arr.length (implies l == arr2.length): (arr.length - k) 
   if l != arr2.length (implies k == arr.length): (arr2.length - l)

so total is

  if k != arr.length: (k + l) + (arr.length - k) = l + arr.length = arr2.length + arr.length
  if l != arr2.length: (k + l) + (arr2.length - l) = k + arr2.length = arr.length + arr2.length

both results in a total execution count of arr.length + arr2.length, hence the complexity is O(m + n)

Answer 4

well since it's only 2 arrays and the algorithm is straight forward, and you are iterating on both arr1 and arr2 on all indexes, the worst case is indeed O(n + m) where n=arr1.length and m=arr2.length. but notice that this is not only the worst case but also the exact time needed meaning its also Θ(m+n)