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

Recall & Review

beginner

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

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

beginner

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

Low (start of the array), Mid (current element), and High (end of the array).

intermediate

In the Dutch National Flag algorithm, what happens when the mid element is equal to the first type?

Swap the mid element with the low element, 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 without nested loops.

intermediate

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

It marks the boundary for the third type elements and moves backward when swapping elements of the third type.

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

A The current element being examined

B The start of the array

C The end of the array

D The middle element of the array

The 'mid' pointer scans through the array, examining each element to decide its position.

When the mid element is the third type, what action is taken?

A Swap with low and increment low and mid

B Increment mid only

C Swap with high and decrement high

D Do nothing and move on

Swap the mid element with the high element and decrement high to move third type elements to the end.

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

A At the start of the array

B One position before the start

C At the middle of the array

D At the end of the array

The 'high' pointer starts at the last index of the array to track the boundary for the third type.

How many passes through the array does the Dutch National Flag algorithm make?

A Depends on array size

B One pass

C Three passes

D Two passes

It makes a single pass by moving pointers and swapping elements as needed.

Which of these is NOT a pointer used in the Dutch National Flag algorithm?

A Pivot

B Mid

C High

D Low

'Pivot' is not used in this algorithm; only low, mid, and high pointers are used.

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

Think about how the pointers move and how elements are swapped based on their type.

Describe why the Dutch National Flag algorithm is efficient compared to sorting the array normally.

Focus on how many times each element is processed and memory usage.

Practice

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

easy

A. To sort an array in ascending order using quicksort

B. To rearrange an array into three parts: less than, equal to, and greater than a pivot

C. To find the maximum element in an array

D. To reverse the elements of an array

Solution

1. Step 1: Understand the partitioning goal

   The algorithm divides the array into three parts based on a pivot value: elements less than pivot, equal to pivot, and greater than pivot.

2. Step 2: Compare with other options

   Options A, C, and D describe different operations: sorting, finding max, and reversing, which are not the main goal here.

3. Final Answer:

   To rearrange an array into three parts: less than, equal to, and greater than a pivot -> Option B

4. Quick Check:

   Partitioning = three parts [OK]

Hint: Remember: three parts based on pivot value [OK]

Common Mistakes:

• Confusing with full sorting algorithms
• Thinking it only separates two parts
• Assuming it finds max or min values

2. Which of the following is the correct way to declare the pointers used in the Dutch National Flag algorithm in C?

easy

A. int low = 0, mid = 0, high = n - 1;

B. int low, mid, high = 0;

C. int low = n, mid = 0, high = n - 1;

D. int low = 0, mid = n - 1, high = 0;

Solution

1. Step 1: Understand pointer initialization

   In the algorithm, low and mid start at 0, and high starts at n-1 (last index).

2. Step 2: Check each option

   int low = 0, mid = 0, high = n - 1; correctly initializes low and mid to 0, high to n-1. Others have incorrect initial values.

3. Final Answer:

   int low = 0, mid = 0, high = n - 1; -> Option A

4. Quick Check:

   Pointers start: low=0, mid=0, high=n-1 [OK]

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

Common Mistakes:

• Setting low or mid to n or n-1 incorrectly
• Not initializing all pointers
• Confusing variable assignments

3. What will be the output array after applying the Dutch National Flag algorithm on arr = {2, 0, 2, 1, 1, 0} with pivot = 1?

medium

A. [0, 0, 1, 1, 2, 2]

B. [2, 2, 1, 1, 0, 0]

C. [1, 1, 0, 0, 2, 2]

D. [0, 1, 2, 0, 1, 2]

Solution

1. Step 1: Partition array around pivot 1

   Elements less than 1: 0,0; equal to 1: 1,1; greater than 1: 2,2.

2. Step 2: Arrange in order less, equal, greater

   So the array becomes [0, 0, 1, 1, 2, 2].

3. Final Answer:

   [0, 0, 1, 1, 2, 2] -> Option A

4. Quick Check:

   Partitioned array = [0,0,1,1,2,2] [OK]

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

Common Mistakes:

• Mixing order of groups
• Not grouping equal elements correctly
• Assuming full sorting instead of partitioning

4. Identify the error in this C code snippet for Dutch National Flag partition:

void dnfPartition(int arr[], int n, int pivot) {
  int low = 0, mid = 0, high = n - 1;
  while (mid <= high) {
    if (arr[mid] < pivot) {
      swap(arr[low], arr[mid]);
      low++;
      mid++;
    } else if (arr[mid] == pivot) {
      mid++;
    } else {
      swap(arr[mid], arr[high]);
      high--;
    }
  }
}

medium

A. Pivot comparison should use > instead of <

B. The loop condition should be mid < high

C. Pointers low and mid should start at n-1

D. swap function is not defined for array elements

Solution

1. Step 1: Check swap usage

   The code uses swap(arr[low], arr[mid]) but swap is not a built-in function in C for array elements.

2. Step 2: Verify other parts

   Loop condition and pointer initialization are correct. Pivot comparisons are correct as per algorithm.

3. Final Answer:

   swap function is not defined for array elements -> Option D

4. Quick Check:

   Missing swap definition = error [OK]

Hint: Remember to define or implement swap for array elements [OK]

Common Mistakes:

• Assuming swap is built-in for arrays in C
• Changing loop condition incorrectly
• Wrong pointer initialization

5. Given an array arr = {3, 5, 2, 3, 8, 3, 1, 3} and pivot = 3, how many swaps will the Dutch National Flag algorithm perform to partition the array?

hard

A. 5

B. 3

C. 4

D. 6

Solution

1. Step 1: Trace swaps during partition

   Initial pointers: low=0, mid=0, high=7. - mid=0 (3 == pivot): mid++ (0 swaps) - mid=1 (5 > pivot): swap arr[mid] and arr[high] -> swap(5,3), high=6 (1 swap) - mid=1 (now 3 == pivot): mid++ (1 swap) - mid=2 (2 < pivot): swap arr[low] and arr[mid] -> swap(3,2), low=1, mid=3 (2 swaps) - mid=3 (3 == pivot): mid++ (2 swaps) - mid=4 (8 > pivot): swap arr[mid] and arr[high] -> swap(8,1), high=5 (3 swaps) - mid=4 (now 1 < pivot): swap arr[low] and arr[mid] -> swap(3,1), low=2, mid=5 (4 swaps) - mid=5 (3 == pivot): mid++ (4 swaps) Loop ends as mid=6 > high=5.

2. Step 2: Count total swaps

   Total swaps performed = 4

3. Final Answer:

   4 -> Option C

4. Quick Check:

   Count swaps carefully = 4 [OK]

Hint: Count swaps during each pointer move carefully [OK]

Common Mistakes:

• Counting swaps only when mid moves
• Ignoring swaps after swapping with high
• Miscounting swaps when elements equal pivot