Merge Two Sorted Arrays Without Extra Space in DSA Javascript - Build from Scratch

Merge Two Sorted Arrays Without Extra Space

📖 Scenario: You have two sorted lists of numbers representing two shelves of books arranged by height. You want to merge these two shelves into one sorted arrangement without using extra space, so you can organize the books efficiently.

🎯 Goal: Build a program that merges two sorted arrays arr1 and arr2 into sorted order without using any extra space (no new arrays). The final sorted numbers should be split between arr1 and arr2 as per their original sizes.

📋 What You'll Learn

Create two sorted arrays arr1 and arr2 with exact values

Create a variable n for the length of arr1 and m for the length of arr2

Implement the merge logic without using extra space

Print the final state of arr1 and arr2 after merging

💡 Why This Matters

🌍 Real World

Merging sorted lists without extra space is useful in memory-limited devices or when working with large datasets where creating extra copies is expensive.

💼 Career

Understanding in-place merging is important for software engineers working on performance-critical applications, embedded systems, or data processing pipelines.

1

Create the two sorted arrays

Create two sorted arrays called arr1 and arr2 with these exact values: arr1 = [1, 5, 9, 10, 15, 20] and arr2 = [2, 3, 8, 13].

DSA Javascript

# Your code here

Hint

Use const arr1 = [...] and const arr2 = [...] with the exact numbers given.

2

Create length variables for both arrays

Create two variables called n and m that store the lengths of arr1 and arr2 respectively.

DSA Javascript

const arr1 = [1, 5, 9, 10, 15, 20];
const arr2 = [2, 3, 8, 13];
// Your code here

Hint

Use const n = arr1.length; and const m = arr2.length;.

3

Merge the two arrays without extra space

Write a nested for loop where the outer loop uses i from 0 to n - 1 and the inner loop uses j from 0 to m - 1. Inside the inner loop, if arr1[i] is greater than arr2[j], swap their values.

DSA Javascript

const arr1 = [1, 5, 9, 10, 15, 20];
const arr2 = [2, 3, 8, 13];
const n = arr1.length;
const m = arr2.length;
// Your code here

Hint

Use two nested loops and swap values when arr1[i] is bigger than arr2[j].

4

Print the final merged arrays

Print the final state of arr1 and arr2 using console.log in this format: arr1: [values] and arr2: [values].

DSA Javascript

const arr1 = [1, 5, 9, 10, 15, 20];
const arr2 = [2, 3, 8, 13];
const n = arr1.length;
const m = arr2.length;

for (let i = 0; i  arr2[j]) {
            const temp = arr1[i];
            arr1[i] = arr2[j];
            arr2[j] = temp;
        }
    }
}
// Your code here

Hint

Use console.log("arr1:", arr1); and console.log("arr2:", arr2); to print the arrays.

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