Quick Sort Algorithm in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Quick Sort Partition Step

What is the output of the array after the partition step in this Quick Sort code snippet?

DSA Javascript

function partition(arr, low, high) {
  let pivot = arr[high];
  let i = low - 1;
  for (let j = low; j < high; j++) {
    if (arr[j] < pivot) {
      i++;
      [arr[i], arr[j]] = [arr[j], arr[i]];
    }
  }
  [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
  return i + 1;
}

let array = [8, 3, 7, 6, 2, 5, 4];
let pivotIndex = partition(array, 0, array.length - 1);
console.log(array);

A [3, 2, 4, 5, 6, 7, 8]

B [2, 3, 4, 5, 6, 7, 8]

C [3, 7, 6, 2, 5, 4, 8]

D [8, 3, 7, 6, 2, 5, 4]

💡 Hint

Focus on how elements smaller than the pivot are moved before it.

The partition function moves all elements smaller than the pivot (8) to the left and places the pivot after them. So the pivot 8 ends up at the last position, and smaller elements are before it but not fully sorted.

❓ Predict Output

intermediate

Final Sorted Array from Quick Sort

What is the output of the array after running the full Quick Sort on this input?

DSA Javascript

function quickSort(arr, low, high) {
  if (low < high) {
    let pi = partition(arr, low, high);
    quickSort(arr, low, pi - 1);
    quickSort(arr, pi + 1, high);
  }
}

function partition(arr, low, high) {
  let pivot = arr[high];
  let i = low - 1;
  for (let j = low; j < high; j++) {
    if (arr[j] < pivot) {
      i++;
      [arr[i], arr[j]] = [arr[j], arr[i]];
    }
  }
  [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
  return i + 1;
}

let array = [10, 7, 8, 9, 1, 5];
quickSort(array, 0, array.length - 1);
console.log(array);

A [5, 1, 7, 8, 9, 10]

B [10, 9, 8, 7, 5, 1]

C [1, 7, 5, 8, 9, 10]

D [1, 5, 7, 8, 9, 10]

💡 Hint

Quick Sort sorts the array in ascending order.

Quick Sort recursively partitions and sorts the array. The final output is the fully sorted array in ascending order.

🧠 Conceptual

advanced

Understanding Quick Sort Pivot Choice Impact

Which statement best explains how the choice of pivot affects Quick Sort's performance?

A Choosing the middle element as pivot always guarantees the fastest sorting.

B Choosing a pivot that splits the array into two nearly equal parts leads to better average performance.

C Pivot choice does not affect Quick Sort's performance at all.

D Choosing the smallest element as pivot always results in the best case time complexity.

💡 Hint

Think about how balanced partitions affect recursion depth.

Quick Sort performs best when the pivot divides the array into two roughly equal parts, minimizing recursion depth and comparisons.

🔧 Debug

advanced

Identify the Bug in Quick Sort Partition

What error will this Quick Sort partition function cause when run?

DSA Javascript

function partition(arr, low, high) {
  let pivot = arr[low];
  let i = low + 1;
  for (let j = low + 1; j <= high; j++) {
    if (arr[j] < pivot) {
      [arr[i], arr[j]] = [arr[j], arr[i]];
      i++;
    }
  }
  [arr[low], arr[i - 1]] = [arr[i - 1], arr[low]];
  return i - 1;
}

let array = [4, 5, 3, 7, 2];
let pi = partition(array, 0, array.length - 1);
console.log(array);

A Array is incorrectly partitioned with pivot not in correct position.

B SyntaxError due to invalid swap syntax.

C TypeError because i is undefined.

D No error, array is correctly partitioned.

💡 Hint

Check the final swap indices carefully.

The final swap uses arr[i] but i points one past the last smaller element, causing pivot to be placed incorrectly.

🚀 Application

expert

Quick Sort on Linked List

Which approach is best to implement Quick Sort on a singly linked list?

A Use the last node as pivot and rearrange nodes by changing links without extra space.

B Use merge sort instead because quick sort is not suitable for linked lists.

C Convert linked list to array, quick sort array, then rebuild linked list.

D Quick sort cannot be implemented on linked lists.

💡 Hint

Think about how to rearrange nodes efficiently in a linked list.

Quick Sort can be done in-place on linked lists by choosing a pivot and rearranging nodes by changing pointers, avoiding extra space.

Practice

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

easy

A. Sort the array by repeatedly selecting the smallest element

B. Compare every element with every other element and swap if needed

C. Divide the array into smaller parts using a pivot and sort them recursively

D. Merge two sorted arrays into one sorted array

Solution

1. Step 1: Understand Quick Sort's approach

   Quick Sort picks a pivot element and divides the array into parts smaller and larger than the pivot.

2. Step 2: Recursive sorting of parts

   It then sorts these parts by calling itself recursively until the whole array is sorted.

3. Final Answer:

   Divide the array into smaller parts using a pivot and sort them recursively -> Option C

4. Quick Check:

   Quick Sort = Divide and conquer [OK]

Hint: Remember: pivot divides array, then sort parts recursively [OK]

Common Mistakes:

• Thinking Quick Sort compares all pairs directly
• Confusing Quick Sort with Selection Sort
• Believing Quick Sort merges arrays like Merge Sort

2. Which of the following is the correct syntax to swap two elements arr[i] and arr[j] in JavaScript during Quick Sort?

easy

A. arr[i], arr[j] = arr[j], arr[i];

B. temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;

C. swap(arr[i], arr[j]);

D. arr[i] = arr[j]; arr[j] = arr[i];

Solution

1. Step 1: Identify correct swap method in JavaScript

   JavaScript does not support tuple unpacking like Python, so swapping requires a temporary variable.

2. Step 2: Check each option

   temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; uses a temporary variable to swap correctly. arr[i], arr[j] = arr[j], arr[i]; is Python syntax, swap(arr[i], arr[j]); is undefined, arr[i] = arr[j]; arr[j] = arr[i]; overwrites values incorrectly.

3. Final Answer:

   temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; -> Option B

4. Quick Check:

   Swap with temp variable = temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; [OK]

Hint: Use a temp variable to swap in JavaScript [OK]

Common Mistakes:

• Using Python-style tuple swap in JavaScript
• Overwriting one element before saving it
• Calling undefined swap function

3. What will be the output of the following Quick Sort partition step on array [4, 2, 7, 1] with pivot as the last element?

function partition(arr, low, high) {
  let pivot = arr[high];
  let i = low - 1;
  for (let j = low; j < high; j++) {
    if (arr[j] < pivot) {
      i++;
      let temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;
    }
  }
  let temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp;
  return i + 1;
}

let arr = [4, 2, 7, 1];
let pi = partition(arr, 0, arr.length - 1);
console.log(arr);

medium

A. [1, 2, 7, 4]

B. [1, 2, 4, 7]

C. [4, 2, 7, 1]

D. [2, 1, 4, 7]

Solution

1. Step 1: Trace the partition loop

   Pivot = 1. Loop checks elements less than 1. No elements are less, so i stays at -1.

2. Step 2: Swap pivot with element at i+1

   Swap arr[0] and arr[3]: 4 and 1 swap places. Array becomes [1, 2, 7, 4].

3. Final Answer:

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

4. Quick Check:

   Pivot 1 placed at start, others unchanged [OK]

Hint: Pivot swaps with first bigger element after loop [OK]

Common Mistakes:

• Assuming pivot stays at end
• Swapping wrong elements after loop
• Not updating i correctly

4. Identify the error in this Quick Sort partition function:

function partition(arr, low, high) {
  let pivot = arr[low];
  let i = low + 1;
  for (let j = low + 1; j <= high; j++) {
    if (arr[j] <= pivot) {
      let temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;
      i++;
    }
  }
  let temp = arr[low]; arr[low] = arr[i]; arr[i] = temp;
  return i;
}

medium

A. Loop should start from low, not low + 1

B. Pivot should be arr[high], not arr[low]

C. No error, function is correct

D. Swapping pivot with arr[i] should be with arr[i - 1]

Solution

1. Step 1: Understand pivot placement

   Pivot is arr[low]. After loop, pivot must be placed at correct position.

2. Step 2: Check swap of pivot with arr[i]

   Variable i points to next greater element, so pivot should swap with arr[i - 1], not arr[i].

3. Final Answer:

   Swapping pivot with arr[i] should be with arr[i - 1] -> Option D

4. Quick Check:

   Pivot swap index off by one [OK]

Hint: Pivot swap index is i-1 after partition loop [OK]

Common Mistakes:

• Swapping pivot with wrong index
• Confusing pivot position in array
• Changing loop start incorrectly

5. Which of the following pivot selection strategies in Quick Sort will result in the most balanced partitions and thus better performance?

hard

A. Choosing the median of first, middle, and last elements as pivot

B. Choosing the first element as pivot

C. Choosing the middle element as pivot

D. Choosing the last element as pivot

Solution

1. Step 1: Understand pivot selection strategies

   Choosing first or last can lead to worst-case O(n^2) on sorted arrays. Middle element alone may not be representative.

2. Step 2: Best strategy for balance

   Median-of-three selects a pivot likely closer to the array's true median, promoting balanced partitions and average O(n log n) performance.

3. Final Answer:

   Choosing the median of first, middle, and last elements as pivot -> Option A

4. Quick Check:

   Median-of-three pivot = balanced partitions [OK]

Hint: Median-of-three pivot improves balance and speed [OK]

Common Mistakes:

• Always picking first or last element as pivot
• Ignoring pivot choice impact on performance
• Assuming middle element is always best pivot