Partition Array According to Given Pivot - Practice Coding Problems

Partition Array According to Given Pivot - Problem

You are given a 0-indexed integer array nums and an integer pivot. Your task is to rearrange the array according to specific partitioning rules while maintaining the relative order of elements within each partition.

Partitioning Rules:

All elements less than pivot must appear first
All elements equal to pivot must appear in the middle
All elements greater than pivot must appear last
Crucially: The relative order within each group must be preserved

Example: Given nums = [9,12,5,10,14,3,10] and pivot = 10
Result: [9,5,3,10,10,12,14]
(Less than 10: [9,5,3], Equal to 10: [10,10], Greater than 10: [12,14])

This is like organizing a queue where you need to maintain the original arrival order within each priority group!

Input & Output

example_1.py — Basic Partitioning

$ Input: nums = [9,12,5,10,14,3,10], pivot = 10

› Output: [9,5,3,10,10,12,14]

💡 Note: Elements less than 10: [9,5,3] (maintaining original order), elements equal to 10: [10,10], elements greater than 10: [12,14] (maintaining original order)

example_2.py — All Elements Equal

$ Input: nums = [5,5,5,5], pivot = 5

› Output: [5,5,5,5]

💡 Note: All elements are equal to the pivot, so they all go in the middle section, maintaining their original relative order

example_3.py — Already Partitioned

$ Input: nums = [1,2,6,7], pivot = 5

› Output: [1,2,6,7]

💡 Note: Array is already correctly partitioned: [1,2] are less than 5, no elements equal to 5, [6,7] are greater than 5

Visualization

Tap to expand

Understanding the Visualization

Mixed Queue

All passengers are initially in one mixed line

Check Tickets

Look at each passenger's ticket and direct them to the appropriate lane

Separate Lanes

Economy, Business, and First Class passengers are now in separate lanes

Final Order

Combine the lanes: Economy → Business → First Class

Key Takeaway

🎯 Key Insight: Instead of complex in-place rearrangement, create three separate collections and merge them - this naturally preserves order and achieves optimal time complexity!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to categorize elements, plus O(n) to combine arrays

✓ Linear Growth

Space Complexity

O(n)

Need space for three separate arrays that together contain all n elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶
pivot equals to one of the elements in nums
The relative order within each partition must be maintained

Asked in

a Amazon 35 ⊞ Microsoft 28 G Google 22 f Meta 18

The optimal solution uses a three-array approach where we make a single pass through the input array and distribute elements into separate arrays based on their relationship to the pivot. This naturally preserves the relative order within each group and achieves O(n) time complexity with O(n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Three Separate Arrays (Optimal)	O(n)	O(n)	Collect elements into three separate arrays, then combine them

Three Separate Arrays (Optimal) — Algorithm Steps

Initialize three empty arrays: less, equal, greater
Iterate through the input array once
For each element, compare with pivot and add to appropriate array
Concatenate the three arrays in order: less + equal + greater
Return the combined result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Arrays

Create three empty arrays for less, equal, and greater elements

Scan and Categorize

Go through each element and place it in the appropriate array

Combine Results

Concatenate the three arrays to get the final partitioned array

Code -

solution.c — C

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

int* pivotArray(int* nums, int numsSize, int pivot, int* returnSize) {
    int* less = malloc(numsSize * sizeof(int));
    int* equal = malloc(numsSize * sizeof(int));
    int* greater = malloc(numsSize * sizeof(int));
    int lessCount = 0, equalCount = 0, greaterCount = 0;
    
    // Single pass to categorize elements
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < pivot) {
            less[lessCount++] = nums[i];
        } else if (nums[i] == pivot) {
            equal[equalCount++] = nums[i];
        } else {
            greater[greaterCount++] = nums[i];
        }
    }
    
    // Combine the three arrays
    int* result = malloc(numsSize * sizeof(int));
    int index = 0;
    
    for (int i = 0; i < lessCount; i++) result[index++] = less[i];
    for (int i = 0; i < equalCount; i++) result[index++] = equal[i];
    for (int i = 0; i < greaterCount; i++) result[index++] = greater[i];
    
    free(less); free(equal); free(greater);
    *returnSize = numsSize;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to categorize elements, plus O(n) to combine arrays

✓ Linear Growth

Space Complexity

O(n)

Need space for three separate arrays that together contain all n elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶
pivot equals to one of the elements in nums
The relative order within each partition must be maintained

24.5K Views

Medium Frequency

~12 min Avg. Time

890 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Three Separate Arrays (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler