Insertion Sort Algorithm in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start the outer loop from the second element in the array.

DSA Javascript

for(let i = [1]; i < arr.length; i++) {
  // sorting logic
}

Drag options to blanks, or click blank then click option'

A1

B2

Carr.length - 1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Starting from index 0 causes unnecessary comparisons.

Starting from the last element misses sorting the array.

The insertion sort starts from the second element (index 1) because the first element is considered sorted.

2fill in blank

medium

Complete the code to store the current element to be inserted in a variable.

DSA Javascript

let key = arr[[1]];

Drag options to blanks, or click blank then click option'

Aarr.length - 1

Bi - 1

C0

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Using i - 1 gets the previous element, not the current one.

Using 0 or arr.length - 1 does not refer to the current element.

The variable key holds the element at index i which we want to insert into the sorted part.

3fill in blank

hard

Fix the error in the while loop condition to correctly compare elements for insertion.

DSA Javascript

while(j >= 0 && arr[j] [1] key) {
  arr[j + 1] = arr[j];
  j--;
}

Drag options to blanks, or click blank then click option'

A<

B==

C>

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' reverses the logic and breaks sorting.

Using '==' or '<=' does not correctly shift elements.

The condition arr[j] > key checks if the current element is greater than the key to shift it right.

4fill in blank

hard

Fill both blanks to correctly shift elements right.

DSA Javascript

arr[j [1] 1] = arr[j];
j = j [2] 1;

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' for the array index causes overwriting.

Incrementing j instead of decrementing causes infinite loop.

We shift elements right by assigning to arr[j + 1] and move j left by decrementing it with j - 1.

5fill in blank

hard

Fill all three blanks to complete the insertion of the key after shifting elements.

DSA Javascript

arr[j [1] 1] = [2];

for(let i = [3]; i < arr.length; i++) {
  // insertion sort logic
}

Drag options to blanks, or click blank then click option'

A+

Bkey

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' causes wrong insertion position.

Using wrong variable instead of key overwrites data.

Starting loop at 0 causes unnecessary comparisons.

After shifting, we place the key at arr[j + 1]. The outer loop starts from index 1 because the first element is considered sorted.

Practice

1. What is the main idea behind the Insertion Sort algorithm?

easy

A. Build the sorted array one element at a time by inserting elements in the correct position

B. Divide the array into halves and sort each half separately

C. Swap adjacent elements if they are in the wrong order repeatedly

D. Select the smallest element and swap it with the first unsorted element

Solution

1. Step 1: Understand insertion sort process

   Insertion sort builds the sorted list by taking one element at a time and placing it in the correct position among the already sorted elements.

2. Step 2: Compare with other sorting methods

   Other options describe different algorithms: dividing (merge sort), swapping adjacent (bubble sort), selecting smallest (selection sort).

3. Final Answer:

   Build the sorted array one element at a time by inserting elements in the correct position -> Option A

4. Quick Check:

   Insertion sort = Insert elements step-by-step [OK]

Hint: Insertion sort inserts elements one by one in order [OK]

Common Mistakes:

• Confusing insertion sort with bubble sort
• Thinking it divides the array like merge sort
• Mixing it up with selection sort

2. Which of the following is the correct syntax to start the outer loop for insertion sort in JavaScript for an array arr?

easy

A. for(let i = 0; i < arr.length; i++)

B. for(let i = 1; i < arr.length; i++)

C. for(let i = arr.length - 1; i >= 0; i--)

D. for(let i = 0; i <= arr.length; i++)

Solution

1. Step 1: Identify starting index for insertion sort

   Insertion sort starts from the second element (index 1) because the first element is considered sorted.

2. Step 2: Check loop condition correctness

   The loop runs while i < arr.length to cover all elements. Starting at 0 or going beyond length is incorrect.

3. Final Answer:

   for(let i = 1; i < arr.length; i++) -> Option B

4. Quick Check:

   Start loop at 1 for insertion sort [OK]

Hint: Start outer loop at 1, not 0, in insertion sort [OK]

Common Mistakes:

• Starting loop at 0 instead of 1
• Using <= instead of < in loop condition
• Looping backwards incorrectly

3. What will be the output of the following JavaScript code?

function insertionSort(arr) {
  for(let i = 1; i < arr.length; i++) {
    let key = arr[i];
    let j = i - 1;
    while(j >= 0 && arr[j] > key) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = key;
  }
  return arr;
}

console.log(insertionSort([4, 2, 7, 1]));

medium

A. [2, 1, 4, 7]

B. [4, 2, 7, 1]

C. [1, 4, 2, 7]

D. [1, 2, 4, 7]

Solution

1. Step 1: Trace first iteration (i=1)

   key=2, compare with 4, shift 4 right, insert 2 at index 0 -> [2,4,7,1]

2. Step 2: Trace remaining iterations

   i=2: key=7, no shift -> [2,4,7,1]; i=3: key=1, shift 7,4,2 right, insert 1 at index 0 -> [1,2,4,7]

3. Final Answer:

   [1, 2, 4, 7] -> Option D

4. Quick Check:

   Sorted array = [1, 2, 4, 7] [OK]

Hint: Insertion sort outputs sorted array in ascending order [OK]

Common Mistakes:

• Not shifting elements correctly
• Returning original array without sorting
• Confusing key placement index

4. Find the error in this insertion sort code snippet:

function insertionSort(arr) {
  for(let i = 1; i <= arr.length; i++) {
    let key = arr[i];
    let j = i - 1;
    while(j >= 0 && arr[j] > key) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = key;
  }
  return arr;
}

medium

A. The outer loop condition should be i < arr.length instead of <=.

B. The inner while loop condition should be arr[j] < key.

C. The key should be assigned after the while loop, not before.

D. The variable j should start at i, not i - 1.

Solution

1. Step 1: Check outer loop boundary

   The loop runs from 1 to arr.length inclusive, but array indices go from 0 to arr.length - 1, so i < arr.length is correct.

2. Step 2: Verify other parts

   Inner loop condition and key assignment are correct; j starts at i - 1 to compare with previous elements.

3. Final Answer:

   The outer loop condition should be i < arr.length instead of <=. -> Option A

4. Quick Check:

   Loop must not exceed array length [OK]

Hint: Use i < arr.length to avoid out-of-bounds [OK]

Common Mistakes:

• Using <= causes index out of range error
• Changing inner loop condition incorrectly
• Misplacing key assignment

5. Given the array [3, 0, -2, 5, 1], after the second iteration (i=2) of insertion sort, what will the array look like?

hard

A. [0, 3, -2, 5, 1]

B. [0, -2, 3, 5, 1]

C. [-2, 0, 3, 5, 1]

D. [3, 0, -2, 5, 1]

Solution

1. Step 1: Trace first iteration (i=1)

   key=0, compare with 3, shift 3 right, insert 0 at index 0 -> [0,3,-2,5,1]

2. Step 2: Trace second iteration (i=2)

   key=-2, compare with 3 and 0, shift both right, insert -2 at index 0 -> [-2,0,3,5,1]

3. Final Answer:

   [-2, 0, 3, 5, 1] -> Option C

4. Quick Check:

   After 2 iterations, array is partially sorted [OK]

Hint: After i-th iteration, first i+1 elements are sorted [OK]

Common Mistakes:

• Not shifting all larger elements
• Inserting key at wrong position
• Confusing iteration count with index