Dutch National Flag Three Way Partition in DSA Javascript - Build from Scratch

Dutch National Flag Three Way Partition

📖 Scenario: Imagine you have a list of colored balls represented by numbers: 0 for red, 1 for white, and 2 for blue. You want to sort them so that all reds come first, then whites, and then blues, just like the Dutch flag.

🎯 Goal: You will write a program that rearranges an array of 0s, 1s, and 2s so that all 0s come first, followed by all 1s, and then all 2s.

📋 What You'll Learn

Create an array called colors with the exact values: [2, 0, 2, 1, 1, 0]

Create a variable called low and set it to 0

Use a while loop with a variable mid starting at 0 and a variable high starting at the last index of colors

Inside the loop, rearrange the elements so that all 0s are before low, all 1s between low and high, and all 2s after high

Print the colors array after sorting

💡 Why This Matters

🌍 Real World

Sorting items into categories quickly and efficiently is useful in many applications like organizing data, color sorting in graphics, or grouping similar objects.

💼 Career

Understanding partitioning algorithms like Dutch National Flag is important for software engineers working on sorting, searching, and optimizing data processing.

1

Create the initial array

Create an array called colors with these exact values: [2, 0, 2, 1, 1, 0]

DSA Javascript

// Your code here

Hint

Use const colors = [2, 0, 2, 1, 1, 0]; to create the array.

2

Set up pointers for partitioning

Create variables called low and mid and set both to 0. Create a variable called high and set it to colors.length - 1

DSA Javascript

const colors = [2, 0, 2, 1, 1, 0];
// Your code here

Hint

Use let low = 0;, let mid = 0;, and let high = colors.length - 1;.

3

Implement the Dutch National Flag partition logic

Use a while loop with the condition mid <= high. Inside the loop, check the value at colors[mid]. If it is 0, swap it with colors[low], then increment low and mid. If it is 1, just increment mid. If it is 2, swap it with colors[high] and decrement high.

DSA Javascript

const colors = [2, 0, 2, 1, 1, 0];
let low = 0;
let mid = 0;
let high = colors.length - 1;
// Your code here

Hint

Use a while loop and swap elements using destructuring assignment.

4

Print the sorted array

Write console.log(colors) to print the sorted colors array

DSA Javascript

const colors = [2, 0, 2, 1, 1, 0];
let low = 0;
let mid = 0;
let high = colors.length - 1;

while (mid <= high) {
    if (colors[mid] === 0) {
        [colors[low], colors[mid]] = [colors[mid], colors[low]];
        low++;
        mid++;
    } else if (colors[mid] === 1) {
        mid++;
    } else { // colors[mid] === 2
        [colors[mid], colors[high]] = [colors[high], colors[mid]];
        high--;
    }
}
// Your code here

Hint

Use console.log(colors) to print the array.

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