Strategy Pattern Sorter - Problem

Implement a flexible sorting system using the Strategy Pattern that can dynamically switch between different sorting algorithms at runtime.

Your task is to create a Sorter class that can use three different sorting strategies:

Bubble Sort: Repeatedly compares adjacent elements and swaps them if they're in wrong order
Insertion Sort: Builds the sorted array one element at a time by inserting each element in its correct position
Selection Sort: Finds the minimum element and places it at the beginning, then repeats for remaining elements

The system should accept an array of integers and a strategy name ("bubble", "insertion", or "selection"), then return the sorted array using the specified algorithm.

This demonstrates the Strategy Pattern's power to swap algorithms without changing the client code, making your sorting system extensible and maintainable.

Input & Output

Example 1 — Bubble Sort Strategy

$ Input: arr = [64,34,25,12], strategy = "bubble"

› Output: [12,25,34,64]

💡 Note: Using bubble sort: repeatedly compares adjacent elements [64,34] → [34,64], then [64,25] → [25,64], etc. After multiple passes, smallest elements "bubble up" to correct positions.

Example 2 — Insertion Sort Strategy

$ Input: arr = [5,2,4,6,1,3], strategy = "insertion"

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

💡 Note: Using insertion sort: takes each element and inserts it into correct position in the already-sorted left portion. Like organizing playing cards in your hand.

Example 3 — Selection Sort Strategy

$ Input: arr = [29,10,14,37,13], strategy = "selection"

› Output: [10,13,14,29,37]

💡 Note: Using selection sort: finds minimum element (10) and places it first, then finds next minimum (13) and places it second, repeating until sorted.

Constraints

1 ≤ arr.length ≤ 1000
-1000 ≤ arr[i] ≤ 1000
strategy ∈ {"bubble", "insertion", "selection"}

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 42 🍎 Apple 35

The Strategy Pattern provides a clean way to swap algorithms at runtime. The key insight is creating an interface that all sorting strategies implement, then using a context class to manage strategy selection. Best approach uses proper OOP design with interface abstraction. Time: O(n²), Space: O(1)

Common Approaches

✓ Complete Strategy Pattern Implementation

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

Implements the complete Strategy Pattern with proper interface abstraction, concrete strategy classes for each sorting algorithm, and a context class that manages strategy selection and execution.

Strategy Pattern with Bubble Sort

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

Create a strategy pattern implementation where bubble sort repeatedly compares adjacent elements and swaps them if they're in wrong order. The pattern allows switching between different sorting algorithms dynamically.

Complete Strategy Pattern Implementation — Algorithm Steps

Step 1: Define SortStrategy interface with sort method
Step 2: Implement three concrete strategies (Bubble, Insertion, Selection)
Step 3: Create Sorter context class with strategy map
Step 4: Dynamically select and execute appropriate strategy

Visualization

Tap to expand

Step-by-Step Walkthrough

Interface Definition

SortStrategy interface defines common sort method

Concrete Strategies

Three sorting algorithms implement the interface

Context Management

Sorter class manages strategy selection and execution

Code -

solution.c — C

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

typedef struct {
    void (*sort)(int* arr, int n);
} SortStrategy;

void bubbleSort(int* arr, int n) {
    for (int i = 0; i < n; i++) {
        int swapped = 0;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = 1;
            }
        }
        if (!swapped) break;
    }
}

void insertionSort(int* arr, int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

void selectionSort(int* arr, int n) {
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIdx];
        arr[minIdx] = temp;
    }
}

SortStrategy* getStrategy(char* strategyName) {
    static SortStrategy bubbleStrategy = {bubbleSort};
    static SortStrategy insertionStrategy = {insertionSort};
    static SortStrategy selectionStrategy = {selectionSort};
    
    if (strcmp(strategyName, "bubble") == 0) {
        return &bubbleStrategy;
    } else if (strcmp(strategyName, "insertion") == 0) {
        return &insertionStrategy;
    } else if (strcmp(strategyName, "selection") == 0) {
        return &selectionStrategy;
    }
    return NULL;
}

int* solution(int* arr, int size, char* strategy) {
    int* result = malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) {
        result[i] = arr[i];
    }
    
    SortStrategy* sortStrategy = getStrategy(strategy);
    if (sortStrategy && sortStrategy->sort) {
        sortStrategy->sort(result, size);
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array from JSON format
    int arr[100];
    int size = 0;
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token != NULL && size < 100) {
            arr[size++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    char strategy[20];
    fgets(strategy, sizeof(strategy), stdin);
    strategy[strcspn(strategy, "\n")] = 0;
    
    int* result = solution(arr, size, strategy);
    
    // Print result in JSON format
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", result[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

All three implemented algorithms (bubble, insertion, selection) have O(n²) worst-case time complexity

⚠ Quadratic Growth

Space Complexity

O(1)

In-place sorting algorithms use only constant extra space for variables

✓ Linear Space

23.4K Views

Medium Frequency

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

Strategy Pattern Sorter - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Complete Strategy Pattern Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler