Dutch National Flag - Problem

Given an array containing only 0s, 1s, and 2s, sort the array in-place in a single pass without using any sorting algorithm or counting sort.

The array represents the colors of the Dutch national flag: 0 represents red, 1 represents white, and 2 represents blue.

Example:

Input: [2,0,2,1,1,0]
Output: [0,0,1,1,2,2]

Constraints:

The array contains only integers 0, 1, and 2
You must solve this in one pass through the array
Use constant extra space

Input & Output

Example 1 — Mixed Colors

$ Input: nums = [2,0,2,1,1,0]

› Output: [0,0,1,1,2,2]

💡 Note: All 0s (red) come first, then 1s (white), then 2s (blue). The Dutch flag pattern is achieved in one pass.

Example 2 — Already Sorted

$ Input: nums = [0,1,2]

› Output: [0,1,2]

💡 Note: Array is already in Dutch flag order, algorithm recognizes this and maintains the sorting.

Example 3 — Reverse Order

$ Input: nums = [2,1,0]

› Output: [0,1,2]

💡 Note: Worst case: completely reverse order gets sorted to proper Dutch flag sequence.

Constraints

1 ≤ nums.length ≤ 300
nums[i] is either 0, 1, or 2

Visualization

Tap to expand

Asked in

M Microsoft 45 a Amazon 38 G Google 32 🍎 Apple 28

The Dutch National Flag problem is solved optimally using three-way partitioning with three pointers (low, mid, high). The key insight is maintaining three zones: processed 0s, processed 1s, and unprocessed elements. Best approach uses the Dutch Flag algorithm in single pass. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force Sort

⏱️ Time: O(n log n) Space: O(log n)

Apply any standard sorting algorithm like quicksort or mergesort to sort the entire array. This ignores the constraint that we should do it in one pass.

Dutch National Flag (Optimal)

⏱️ Time: O(n) Space: O(1)

Use three pointers (low, mid, high) to partition array into three regions in one pass. Low tracks position for next 0, high tracks position for next 2, mid scans through array.

Two-Pass Counting

⏱️ Time: O(n) Space: O(1)

First pass counts how many 0s, 1s, and 2s exist. Second pass overwrites the array by placing all 0s first, then 1s, then 2s based on counts.

Brute Force Sort — Algorithm Steps

Apply built-in sort function
Return the sorted array

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Array

Unsorted array with 0s, 1s, and 2s

Apply Sort

Use quicksort, mergesort, or built-in sort

Result

Array is sorted but took O(n log n) time

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int* solution(int* nums, int size) {
    qsort(nums, size, sizeof(int), compare);
    return nums;
}

int* parseArray(char* s, int* size) {
    int* result = malloc(1000 * sizeof(int));
    *size = 0;
    
    char* token = strtok(s + 1, ",]");
    while (token != NULL) {
        result[(*size)++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    return result;
}

void printArray(int* arr, int size) {
    printf("[");
    for (int i = 0; i < size; i++) {
        if (i > 0) printf(",");
        printf("%d", arr[i]);
    }
    printf("]\n");
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int size;
    int* nums = parseArray(line, &size);
    
    solution(nums, size);
    printArray(nums, size);
    
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Standard comparison-based sorting algorithms take O(n log n) time

⚡ Linearithmic

Space Complexity

O(log n)

Sorting algorithms typically use O(log n) space for recursion stack

⚡ Linearithmic Space

187.6K Views

High Frequency

~15 min Avg. Time

8.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Dutch National Flag - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler