Quick Sort with Pivot Strategies - Problem

Implement quick sort with three different pivot selection strategies: first element, last element, and median-of-three.

Your task is to sort an array using quick sort and return the sorted array. The pivot strategy determines which element is chosen as the partition pivot during each recursive call.

Pivot Strategies:

first: Always choose the first element as pivot
last: Always choose the last element as pivot
median-of-three: Choose the median of first, middle, and last elements as pivot

Return the sorted array using the specified pivot strategy.

Input & Output

Example 1 — Basic Array with First Pivot

$ Input: nums = [3,6,8,2,5], strategy = "first"

› Output: [2,3,5,6,8]

💡 Note: Using first element (3) as pivot repeatedly. First partition puts 2 left of 3, then 5,6,8 right. Continue recursively until sorted.

Example 2 — Same Array with Median-of-Three

$ Input: nums = [3,6,8,2,5], strategy = "median-of-three"

› Output: [2,3,5,6,8]

💡 Note: Find median of first=3, middle=8, last=5 → median=5. Use 5 as pivot for more balanced partitioning.

Example 3 — Already Sorted with Last Pivot

$ Input: nums = [1,2,3,4,5], strategy = "last"

› Output: [1,2,3,4,5]

💡 Note: Array already sorted. Last pivot strategy handles this case efficiently by using last element (5) as pivot.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁶ ≤ nums[i] ≤ 10⁶
strategy is one of: "first", "last", "median-of-three"

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 A Apple 12

The key insight is that pivot selection strategy dramatically affects quick sort performance. Median-of-three approach provides the best balance by avoiding worst-case scenarios on sorted data. Time: O(n log n), Space: O(log n)

Common Approaches

✓ First Element Pivot

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

The simplest pivot selection strategy where we consistently pick the first element of each subarray as the pivot. While easy to implement, this can lead to worst-case O(n²) performance on already sorted arrays.

Last Element Pivot

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

A common pivot selection strategy that chooses the last element of each subarray as the pivot. This is often more intuitive for partitioning logic and performs similarly to first-element pivot on random data.

Median-of-Three Pivot

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

The most sophisticated pivot selection strategy that examines three elements (first, middle, last) and chooses the median value as pivot. This approach significantly reduces the chance of worst-case scenarios and provides more balanced partitions.

First Element Pivot — Algorithm Steps

Choose first element as pivot
Partition array around pivot
Recursively sort left and right subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose First

Select first element [3] as pivot

Partition

Move smaller elements left, larger right

Recurse

Apply same strategy to subarrays

Code -

solution.c — C

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

void quicksort(int arr[], int low, int high);
int partitionFirst(int arr[], int low, int high);

int* solution(int* nums, int numsSize, char* strategy, int* returnSize) {
    int* result = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        result[i] = nums[i];
    }
    
    if (strcmp(strategy, "first") == 0) {
        quicksort(result, 0, numsSize - 1);
    }
    
    *returnSize = numsSize;
    return result;
}

void quicksort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partitionFirst(arr, low, high);
        quicksort(arr, low, pi - 1);
        quicksort(arr, pi + 1, high);
    }
}

int partitionFirst(int arr[], int low, int high) {
    int pivot = arr[low];  // First element as pivot
    int i = low + 1;
    int j = high;
    
    while (1) {
        while (i <= j && arr[i] <= pivot) i++;
        while (i <= j && arr[j] > pivot) j--;
        if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        } else {
            break;
        }
    }
    
    int temp = arr[low];
    arr[low] = arr[j];
    arr[j] = temp;
    return j;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[100];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int returnSize;
    int* result = solution(nums, numsSize, line, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Average case with random data, but O(n²) worst case on sorted input

⚡ Linearithmic

Space Complexity

O(log n)

Recursion stack depth in average case, O(n) worst case

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 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

Quick Sort with Pivot Strategies - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

First Element Pivot — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler