Merge Two Sorted Arrays Without Extra Space in DSA Javascript - Time & Space Complexity

Time Complexity: Merge Two Sorted Arrays Without Extra Space

O(n * m)

Understanding Time Complexity

We want to know how long it takes to merge two sorted arrays without using extra space.

How does the time needed grow as the arrays get bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function merge(arr1, arr2) {
  let i = 0, j = 0;
  while (i < arr1.length) {
    if (arr1[i] > arr2[0]) {
      [arr1[i], arr2[0]] = [arr2[0], arr1[i]];
      let first = arr2[0];
      let k = 1;
      while (k < arr2.length && arr2[k] < first) {
        arr2[k - 1] = arr2[k];
        k++;
      }
      arr2[k - 1] = first;
    }
    i++;
  }
}
    

This code merges two sorted arrays by swapping elements and keeping the second array sorted without extra space.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Outer while loop runs through all elements of the first array.
• Nested operation: Inner while loop shifts elements in the second array to keep it sorted after a swap.
• How many times: Outer loop runs n times (size of first array), inner loop can run up to m times (size of second array) in worst case.

How Execution Grows With Input

As the arrays get bigger, the number of operations grows because for each element in the first array, we might shift many elements in the second array.

Input Size (n, m)	Approx. Operations
10, 10	Up to 100 (10 * 10)
100, 100	Up to 10,000 (100 * 100)
1000, 1000	Up to 1,000,000 (1000 * 1000)

Pattern observation: The operations grow roughly by the product of the sizes of the two arrays, meaning it grows much faster as arrays get larger.

Final Time Complexity

Time Complexity: O(n * m)

This means the time needed grows proportionally to the size of the first array times the size of the second array.

Common Mistake

[X] Wrong: "Since both arrays are sorted, merging without extra space is always fast and close to O(n + m)."

[OK] Correct: The inner shifting loop can cause many moves, making the process slower than a simple linear pass, especially when many swaps happen.

Interview Connect

Understanding this time complexity helps you explain trade-offs when merging arrays without extra space, showing your grasp of algorithm efficiency and practical coding skills.

Self-Check

"What if we used a gap method (Shell sort idea) to reduce the number of shifts? How would the time complexity change?"

Practice

1. What is the main goal when merging two sorted arrays without extra space?

easy

A. Sort each array separately without merging

B. Create a new array to hold all elements from both arrays

C. Copy elements from one array to another without sorting

D. Combine both arrays into one sorted array without using extra memory

Solution

1. Step 1: Understand the problem requirement

   The problem asks to merge two sorted arrays into a single sorted sequence without using extra space, meaning no additional arrays or large memory allocations.

2. Step 2: Identify the approach

   We must rearrange elements within the given arrays themselves to maintain sorted order combined.

3. Final Answer:

   Combine both arrays into one sorted array without using extra memory -> Option D

4. Quick Check:

   Merge without extra space = Combine in-place [OK]

Hint: Think in-place rearrangement, not new arrays [OK]

Common Mistakes:

• Assuming extra arrays are allowed
• Sorting arrays separately without merging
• Copying elements without sorting

2. Which of the following JavaScript syntax snippets correctly swaps two elements a[i] and b[j] without using a temporary variable?

easy

A. [a[i], b[j]] = [b[j], a[i]];

B. temp = a[i]; a[i] = b[j]; b[j] = temp;

C. a[i] = b[j]; b[j] = a[i];

D. a[i], b[j] = b[j], a[i];

Solution

1. Step 1: Identify correct swap syntax in JavaScript

   Using destructuring assignment, [a[i], b[j]] = [b[j], a[i]]; swaps values without a temporary variable.

2. Step 2: Check other options

   temp = a[i]; a[i] = b[j]; b[j] = temp; uses a temporary variable, C incorrectly assigns twice, D is invalid syntax.

3. Final Answer:

   [a[i], b[j]] = [b[j], a[i]]; -> Option A

4. Quick Check:

   Destructuring swap = [a[i], b[j]] = [b[j], a[i]]; [OK]

Hint: Use destructuring assignment for swap without temp [OK]

Common Mistakes:

• Using invalid syntax like option D
• Forgetting to use a temporary variable if not destructuring
• Assigning values incorrectly causing data loss

3. What will be the content of arrays a and b after running this code?

let a = [1, 5, 9, 10];
let b = [2, 3, 8, 13];

for (let i = 0; i < a.length; i++) {
  if (a[i] > b[0]) {
    [a[i], b[0]] = [b[0], a[i]];
    b.sort((x, y) => x - y);
  }
}

medium

A. a = [1, 2, 3, 5], b = [8, 9, 10, 13]

B. a = [1, 3, 5, 8], b = [2, 9, 10, 13]

C. a = [1, 2, 5, 8], b = [3, 9, 10, 13]

D. a = [1, 2, 3, 8], b = [5, 9, 10, 13]

Solution

1. Step 1: Trace the loop and swaps

   i=0: a[0]=1 <= b[0]=2 no swap
   i=1: a[1]=5 > b[0]=2 swap -> a[1]=2, b[0]=5; b sorted: [3,5,8,13]
   i=2: a[2]=9 > b[0]=3 swap -> a[2]=3, b[0]=9; b sorted: [5,8,9,13]
   i=3: a[3]=10 > b[0]=5 swap -> a[3]=5, b[0]=10; b sorted: [8,9,10,13]

2. Step 2: Final arrays after loop

   a = [1, 2, 3, 5]
   b = [8, 9, 10, 13]

3. Final Answer:

   a = [1, 2, 3, 5], b = [8, 9, 10, 13] -> Option A

4. Quick Check:

   Swapped and sorted b each time = a = [1, 2, 3, 5], b = [8, 9, 10, 13] [OK]

Hint: Swap if a[i] > b[0], then sort b [OK]

Common Mistakes:

• Not sorting array b after swap
• Swapping incorrectly causing wrong order
• Assuming arrays merge into one

4. Identify the error in this code snippet intended to merge two sorted arrays without extra space:

let a = [1, 4, 7];
let b = [2, 5, 6];

for (let i = 0; i < a.length; i++) {
  if (a[i] > b[0]) {
    let temp = a[i];
    a[i] = b[0];
    b[0] = temp;
  }
  b.sort();
}

medium

A. The if condition should be a[i] < b[0] instead of a[i] > b[0]

B. The sort() method is called without a compare function, causing incorrect sorting

C. Loop should run over array b length instead of a length

D. Swapping elements uses a temporary variable incorrectly

Solution

1. Step 1: Check the sorting method used

   The code uses b.sort() without a compare function, which sorts elements as strings, not numbers, causing wrong order.

2. Step 2: Correct sorting approach

   Use b.sort((x, y) => x - y) to sort numbers correctly.

3. Final Answer:

   The sort() method is called without a compare function, causing incorrect sorting -> Option B

4. Quick Check:

   sort() without compare = wrong numeric order [OK]

Hint: Always provide compare function for numeric sort [OK]

Common Mistakes:

• Using default sort() for numbers
• Swapping incorrectly without temp variable
• Wrong loop range

5. Given two sorted arrays a = [1, 3, 5, 7] and b = [0, 2, 6, 8, 9], how can you merge them without extra space so that after merging, a contains the first 4 smallest elements and b contains the remaining elements sorted? Which approach is best?

hard

A. Swap elements only if a[i] > b[j] without sorting b after swaps

B. Concatenate arrays and sort the combined array

C. Use a gap method to compare and swap elements between arrays until fully sorted

D. Copy all elements to a new array and then split back

Solution

1. Step 1: Understand the gap method

   The gap method compares elements at a certain gap distance in both arrays and swaps if needed, reducing the gap until 1, ensuring sorted order without extra space.

2. Step 2: Why other options fail

   Concatenate arrays and sort the combined array and D use extra space, violating constraints. Swap elements only if a[i] > b[j] without sorting b after swaps misses sorting after swaps, causing incorrect order.

3. Final Answer:

   Use a gap method to compare and swap elements between arrays until fully sorted -> Option C

4. Quick Check:

   Gap method = in-place merge without extra space [OK]

Hint: Use gap method to merge in-place efficiently [OK]

Common Mistakes:

• Using extra arrays violating constraints
• Not sorting after swaps causing disorder
• Assuming simple swaps suffice without gap reduction