Dutch National Flag Three Way Partition in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main goal of the Dutch National Flag problem?

To rearrange an array with three distinct values so that all elements of the first value come first, followed by all elements of the second value, and then all elements of the third value.

beginner

Which three pointers are used in the Dutch National Flag algorithm?

Low (start of the first section), Mid (current element), and High (end of the last section).

intermediate

In the Dutch National Flag algorithm, what happens when the mid pointer points to the lowest value?

Swap the element at mid with the element at low, then increment both low and mid pointers.

intermediate

Why does the Dutch National Flag algorithm run in O(n) time?

Because it processes each element at most once by moving pointers forward or backward without nested loops.

intermediate

What is the role of the high pointer in the Dutch National Flag algorithm?

It marks the boundary where elements greater than the middle value are placed, and it moves backward when swapping with mid.

What does the 'mid' pointer represent in the Dutch National Flag algorithm?

A Position of the highest value

B Start of the array

C Current element being examined

D End of the array

The 'mid' pointer scans through the array to examine each element.

When the element at 'mid' is the highest value, what action is taken?

A Swap with element at 'low' and increment both

B Swap with element at 'high' and decrement 'high'

C Increment 'mid' only

D Do nothing and move 'low'

Swap with 'high' and decrement 'high' to move highest values to the end.

What is the initial position of the 'low' pointer?

A At the start of the array

B In the middle of the array

C At the end of the array

D One position after 'mid'

'Low' starts at the beginning to mark the boundary of the lowest values.

Which of these best describes the Dutch National Flag problem?

A Sorting an array of any numbers

B Reversing an array

C Finding the maximum value in an array

D Partitioning an array into three groups based on values

It partitions the array into three groups based on three distinct values.

What happens when the element at 'mid' is the middle value?

A Increment 'mid' only

B Swap with 'high' and decrement 'high'

C Swap with 'low' and increment 'low' and 'mid'

D Decrement 'low'

When 'mid' points to the middle value, just move 'mid' forward.

Explain the step-by-step process of the Dutch National Flag algorithm.

Think about how you separate three colors in a line.

Why is the Dutch National Flag algorithm efficient compared to sorting the entire array?

Consider how many times each element is touched.

Practice

1. What is the main goal of the Dutch National Flag Three Way Partition algorithm?

easy

A. To find the maximum element in an array

B. To sort an array in ascending order using quicksort

C. To reverse the elements of an array

D. To rearrange an array so that all elements less than a pivot come first, then equal elements, then greater elements

Solution

1. Step 1: Understand the partition goal

   The algorithm divides the array into three parts: less than pivot, equal to pivot, and greater than pivot.

2. Step 2: Identify the rearrangement

   It rearranges elements so that all smaller come first, then equal, then larger, without full sorting.

3. Final Answer:

   To rearrange an array so that all elements less than a pivot come first, then equal elements, then greater elements -> Option D

4. Quick Check:

   Partitioning = Rearranging by pivot [OK]

Hint: Remember: three parts - less, equal, greater [OK]

Common Mistakes:

• Confusing partition with full sorting
• Thinking it only finds max or min
• Assuming it reverses the array

2. Which of the following is the correct way to initialize pointers for the Dutch National Flag algorithm in JavaScript?

easy

A. let low = 0, mid = 0, high = arr.length - 1;

B. let low = arr.length - 1, mid = 0, high = 0;

C. let low = 0, mid = arr.length - 1, high = 0;

D. let low = 0, mid = 1, high = arr.length;

Solution

1. Step 1: Identify pointer roles

   Low and mid start at 0, high at last index to cover full array.

2. Step 2: Match initialization to algorithm

   Correct initialization is low=0, mid=0, high=arr.length-1 to scan and partition properly.

3. Final Answer:

   let low = 0, mid = 0, high = arr.length - 1; -> Option A

4. Quick Check:

   Pointers start at array ends and middle [OK]

Hint: Start low and mid at 0, high at last index [OK]

Common Mistakes:

• Setting high to 0 instead of last index
• Starting mid at wrong position
• Using array length instead of length - 1

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

function dutchFlag(arr, pivot) {
  let low = 0, mid = 0, high = arr.length - 1;
  while (mid <= high) {
    if (arr[mid] < pivot) {
      [arr[low], arr[mid]] = [arr[mid], arr[low]];
      low++; mid++;
    } else if (arr[mid] === pivot) {
      mid++;
    } else {
      [arr[mid], arr[high]] = [arr[high], arr[mid]];
      high--;
    }
  }
  return arr;
}

console.log(dutchFlag([2, 5, 1, 2, 3, 2, 4], 2));

medium

A. [1, 2, 2, 2, 5, 3, 4]

B. [2, 2, 2, 1, 3, 4, 5]

C. [1, 2, 2, 2, 3, 4, 5]

D. [1, 2, 2, 2, 4, 3, 5]

Solution

1. Step 1: Trace swaps for elements less than pivot

   Elements less than 2 (which is 1) move to front; 1 swaps to index 0.

2. Step 2: Place all 2s in middle and greater elements at end

   All 2s stay in middle; 3,4,5 move to the right side in any order preserving partition.

3. Final Answer:

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

4. Quick Check:

   Partitioned array with less, equal, greater [OK]

Hint: Swap less than pivot left, greater right [OK]

Common Mistakes:

• Not swapping correctly when element equals pivot
• Mixing order of greater elements
• Forgetting to increment mid after swap with low

4. Identify the bug in this Dutch National Flag partition code:

function partition(arr, pivot) {
  let low = 0, mid = 0, high = arr.length - 1;
  while (mid < high) {
    if (arr[mid] < pivot) {
      [arr[low], arr[mid]] = [arr[mid], arr[low]];
      low++;
      mid++;
    } else if (arr[mid] === pivot) {
      mid++;
    } else {
      [arr[mid], arr[high]] = [arr[high], arr[mid]];
      high--;
    }
  }
  return arr;
}

medium

A. The pointers low and mid are initialized incorrectly

B. The while loop condition should be mid <= high, not mid < high

C. The swap operation is missing for elements equal to pivot

D. The high pointer should be incremented, not decremented

Solution

1. Step 1: Check loop condition correctness

   The loop must run while mid is less than or equal to high to process all elements.

2. Step 2: Identify impact of incorrect condition

   Using mid < high skips processing when mid equals high, missing last element check.

3. Final Answer:

   The while loop condition should be mid <= high, not mid < high -> Option B

4. Quick Check:

   Loop must cover all elements [OK]

Hint: Use mid <= high to cover all elements [OK]

Common Mistakes:

• Using mid < high causes last element to be skipped
• Incorrect pointer initialization
• Misunderstanding swap necessity for equal elements

5. Given an array [4, 9, 4, 7, 4, 8, 7] and pivot value 7, what will be the final array after applying the Dutch National Flag partition algorithm?

hard

A. [4, 4, 4, 7, 7, 8, 9]

B. [4, 4, 4, 7, 8, 7, 9]

C. [4, 4, 4, 7, 8, 9, 7]

D. [7, 7, 4, 4, 4, 8, 9]

Solution

1. Step 1: Partition elements less than pivot (7)

   All 4s move to the front: [4, 4, 4, ...]

2. Step 2: Place all 7s in the middle and greater elements at the end

   7s stay in the middle; 8 and 9 move to the right side in sorted order.

3. Final Answer:

   [4, 4, 4, 7, 7, 8, 9] -> Option A

4. Quick Check:

   Less, equal, greater partitioned correctly [OK]

Hint: Group less, equal, greater around pivot [OK]

Common Mistakes:

• Mixing order of greater elements
• Placing pivot elements incorrectly
• Not moving all less elements to front