Frequency-Based Sorting - Problem

Given an array of integers, sort the elements based on their frequency of occurrence. Elements with higher frequency should appear first in the result.

If two elements have the same frequency, maintain their relative order from the original array (stable sort).

Return the sorted array as the result.

Input & Output

Example 1 — Basic Frequency Sorting

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

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

💡 Note: Elements 1 and 2 both appear 2 times, element 3 appears 1 time. Since 1 and 2 have same frequency, maintain original order where 1 comes first.

Example 2 — Clear Frequency Difference

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

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

💡 Note: Element 2 appears 2 times (first at index 0), element 3 appears 2 times (first at index 1), element 1 appears 1 time. Result: 2s first, then 3s, then 1.

Example 3 — All Same Frequency

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

› Output: [1,2,3]

💡 Note: All elements appear exactly once, so maintain the original order from the input array.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to count element frequencies first, then sort by frequency while maintaining stable order. The optimal approach uses a hash map to count frequencies in O(n) time, sorts unique elements by frequency in O(k log k), and rebuilds the result. Time: O(n log k), Space: O(k) where k is the number of unique elements.

Common Approaches

✓ Brute Force Sorting

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

For each pair of elements during sorting, count their frequencies by scanning the entire array. This leads to many redundant frequency calculations.

Single Pass with Custom Sort

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

Count frequencies while preserving original indices, then use custom comparator to sort elements by frequency and maintain stable ordering.

Two-Pass Hash Map

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

Build a frequency map in first pass, then create result array by processing elements based on their frequencies in second pass.

Brute Force Sorting — Algorithm Steps

For each comparison, count frequency of both elements
Sort based on frequency comparison
Maintain original order for equal frequencies

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Elements

For each pair comparison during sort

Count Frequencies

Scan entire array to count each element

Sort Decision

Place higher frequency element first

Code -

solution.c — C

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

int countFrequency(int* arr, int size, int target) {
    int count = 0;
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) count++;
    }
    return count;
}

void solution(int* nums, int size, int* result) {
    typedef struct {
        int val;
        int index;
    } Pair;
    
    Pair* indexed = (Pair*)malloc(size * sizeof(Pair));
    for (int i = 0; i < size; i++) {
        indexed[i].val = nums[i];
        indexed[i].index = i;
    }
    
    // Bubble sort with frequency comparison
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            int freq1 = countFrequency(nums, size, indexed[j].val);
            int freq2 = countFrequency(nums, size, indexed[j + 1].val);
            if (freq1 < freq2 || (freq1 == freq2 && indexed[j].index > indexed[j + 1].index)) {
                Pair temp = indexed[j];
                indexed[j] = indexed[j + 1];
                indexed[j + 1] = temp;
            }
        }
    }
    
    for (int i = 0; i < size; i++) {
        result[i] = indexed[i].val;
    }
    
    free(indexed);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Sorting takes O(n²) comparisons, each comparison scans array O(n) to count frequency

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses constant extra space for variables

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

847 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

Frequency-Based Sorting - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler