Sort Colors Two Pointer Dutch Flag in DSA Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the Dutch National Flag problem?

It is to sort an array containing three different values (like 0, 1, 2) in a single pass using three pointers to separate the values into three groups.

beginner

In the two-pointer Dutch Flag algorithm, what do the pointers 'low', 'mid', and 'high' represent?

'low' marks the boundary for 0s, 'mid' is the current element under consideration, and 'high' marks the boundary for 2s.

intermediate

Why does the Dutch Flag algorithm only need one pass through the array?

Because it swaps elements in place and moves pointers smartly to ensure each element is checked and placed correctly without revisiting.

beginner

What happens when the 'mid' pointer encounters a 0 in the Dutch Flag algorithm?

The element at 'mid' is swapped with the element at 'low', then both 'low' and 'mid' pointers move forward.

beginner

What is the time complexity of the Dutch Flag sorting algorithm?

It is O(n), where n is the number of elements, because it processes each element once.

What does the 'high' pointer represent in the Dutch Flag algorithm?

A Boundary for 2s

B Boundary for 0s

C Current element under consideration

D End of the array

'high' marks the boundary where all elements to the right are 2s.

When the 'mid' pointer finds a 2, what action is taken?

A Swap with 'low' and move both pointers forward

B Swap with 'mid' itself

C Move 'mid' forward only

D Swap with 'high' and move 'high' backward

Swap the element at 'mid' with the element at 'high', then move 'high' backward without moving 'mid' forward.

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

A At the start of the array

B At the end of the array

C In the middle of the array

D At the same position as 'high'

'mid' starts at the beginning and moves forward as elements are processed.

Which of these is NOT true about the Dutch Flag algorithm?

A It sorts the array in one pass

B It uses extra space proportional to the array size

C It swaps elements in place

D It uses three pointers

The algorithm sorts in place and does not use extra space proportional to the array size.

What is the main advantage of the Dutch Flag algorithm over counting sort for this problem?

A It works for any number of colors

B It is easier to implement

C It uses less memory and sorts in one pass

D It uses recursion

The Dutch Flag algorithm sorts in place with constant extra space and one pass, unlike counting sort which requires extra space.

Explain how the two-pointer Dutch Flag algorithm sorts an array of 0s, 1s, and 2s.

Think about how you separate the colors into three groups using pointers.

Describe the pointer movements and swaps when the current element is 0, 1, or 2 in the Dutch Flag algorithm.

Focus on what happens for each color value.

Practice

1. What is the main goal of the Sort Colors Two Pointer Dutch Flag algorithm?

easy

A. To sort an array containing only 0s, 1s, and 2s in a single pass

B. To sort any array of integers in ascending order

C. To find the maximum value in an array

D. To reverse the elements of an array

Solution

1. Step 1: Understand the problem context

   The algorithm is designed specifically for arrays with only three distinct values: 0, 1, and 2.

2. Step 2: Identify the sorting goal

   The goal is to rearrange the array so that all 0s come first, then all 1s, and finally all 2s, in one pass without extra space.

3. Final Answer:

   To sort an array containing only 0s, 1s, and 2s in a single pass -> Option A

4. Quick Check:

   Sort Colors = Sort 0,1,2 in one pass [OK]

Hint: Remember: Dutch Flag sorts 0,1,2 in one pass [OK]

Common Mistakes:

• Thinking it sorts any integer array
• Confusing it with general sorting algorithms
• Assuming it reverses the array

2. Which of the following Rust code snippets correctly declares the pointers used in the Dutch Flag algorithm?

easy

A. let mut low = 0; let mut mid = 0; let mut high = nums.len() - 1;

B. let low = 0; let mid = 0; let high = nums.len();

C. let mut low = 1; let mut mid = 1; let mut high = nums.len() - 1;

D. let mut low = 0; let mut mid = 1; let mut high = nums.len();

Solution

1. Step 1: Identify pointer initialization

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

2. Step 2: Check mutability and bounds

   All pointers must be mutable to move during sorting, and high must be len() - 1 to avoid out-of-bounds errors.

3. Final Answer:

   let mut low = 0; let mut mid = 0; let mut high = nums.len() - 1; -> Option A

4. Quick Check:

   Correct pointer setup = let mut low = 0; let mut mid = 0; let mut high = nums.len() - 1; [OK]

Hint: Pointers start at 0 except high at last index [OK]

Common Mistakes:

• Setting high to nums.len() causing out-of-bounds
• Not using mutable variables
• Starting pointers at wrong indices

3. What will be the output of the following Rust code after applying the Dutch Flag algorithm?

let mut nums = vec![2, 0, 2, 1, 1, 0];
let mut low = 0;
let mut mid = 0;
let mut high = nums.len() - 1;

while mid <= high {
    match nums[mid] {
        0 => {
            nums.swap(low, mid);
            low += 1;
            mid += 1;
        },
        1 => {
            mid += 1;
        },
        2 => {
            nums.swap(mid, high);
            if high == 0 { break; }
            high -= 1;
        },
        _ => {}
    }
}
println!("{:?}", nums);

medium

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

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

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

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

Solution

1. Step 1: Trace initial swaps and pointer moves

   Starting with nums = [2,0,2,1,1,0], the algorithm swaps 2 at mid with 0 at high, then moves pointers accordingly.

2. Step 2: Continue until mid passes high

   After all swaps and increments, the array becomes sorted as [0, 0, 1, 1, 2, 2].

3. Final Answer:

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

4. Quick Check:

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

Hint: Swap 0s left, 2s right, 1s stay middle [OK]

Common Mistakes:

• Not updating pointers correctly after swap
• Swapping with wrong indices
• Stopping loop too early

4. Identify the bug in this Rust code snippet implementing the Dutch Flag algorithm:

let mut nums = vec![2, 0, 1];
let mut low = 0;
let mut mid = 0;
let mut high = nums.len();

while mid <= high {
    match nums[mid] {
        0 => {
            nums.swap(low, mid);
            low += 1;
            mid += 1;
        },
        1 => {
            mid += 1;
        },
        2 => {
            nums.swap(mid, high);
            high -= 1;
        },
        _ => {}
    }
}

medium

A. The match statement is missing a case for 3

B. mid pointer is not incremented after swapping 2

C. low pointer is incremented incorrectly

D. high is initialized to nums.len(), causing out-of-bounds access

Solution

1. Step 1: Check pointer initialization

   high is set to nums.len(), which is one past the last valid index, causing out-of-bounds when accessing nums[high].

2. Step 2: Understand valid index range

   Valid indices are 0 to nums.len() - 1, so high should be initialized to nums.len() - 1.

3. Final Answer:

   high is initialized to nums.len(), causing out-of-bounds access -> Option D

4. Quick Check:

   high must be last index, not length [OK]

Hint: high = length - 1 to avoid out-of-bounds [OK]

Common Mistakes:

• Using length instead of last index for high
• Not incrementing mid after swapping 2
• Ignoring pointer bounds

5. Given an array nums = [1, 2, 0, 1, 2, 0, 1], how many swaps will the Dutch Flag algorithm perform to sort it?

hard

A. 3

B. 4

C. 5

D. 6

Solution

1. Step 1: Trace swaps during sorting

   Initial array: [1, 2, 0, 1, 2, 0, 1]. Swaps occur when 0 or 2 is found at mid.

2. Step 2: Count swaps step-by-step

   Swaps: - Swap 0 at index 2 with 1 at low (index 0) -> 1 swap - Swap 2 at index 1 with 1 at high (index 6) -> 1 swap - Swap 0 at index 5 with 1 at low (index 1) -> 1 swap - Swap 2 at index 1 with 1 at high (index 5) -> 1 swap Total swaps = 4.

3. Final Answer:

   4 -> Option B

4. Quick Check:

   Count swaps for 0 and 2 moves = 4 [OK]

Hint: Count swaps only when swapping 0 or 2 [OK]

Common Mistakes:

• Counting pointer moves as swaps
• Missing swaps when 2 is swapped
• Assuming swaps equal array length