Sort Array by Increasing Frequency - Practice Coding Problems

Sort Array by Increasing Frequency - Problem

You're given an array of integers and need to sort it in a unique way! Instead of sorting by value, you'll sort by frequency of occurrence.

The Rules:

Sort elements by their frequency in ascending order (least frequent first)
When elements have the same frequency, sort them by value in descending order (largest first)

Example: In [1,1,2,2,2,3], the number 3 appears once (frequency 1), 1 appears twice (frequency 2), and 2 appears three times (frequency 3). So the result would be [3,1,1,2,2,2].

This problem combines frequency counting with custom sorting - perfect for practicing hash tables and sorting algorithms!

Input & Output

example_1.py — Basic Example

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

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

💡 Note: Element 3 has frequency 1, elements 1 have frequency 2, and elements 2 have frequency 3. Sorting by increasing frequency: 3 first, then 1's, then 2's.

example_2.py — Same Frequency

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

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

💡 Note: Both 1 and 2 have frequency 1, but since 2 > 1, we put 2 after 1. Elements 3 have frequency 2, so they come last.

example_3.py — All Same Frequency

$ Input: nums = [-1,1,-6,4,5,-6,1,4,1]

› Output: [5,-1,4,4,-6,-6,1,1,1]

💡 Note: 5 and -1 have frequency 1 (5 > -1), 4 and -6 have frequency 2 (4 > -6), and 1 has frequency 3.

Constraints

1 ≤ nums.length ≤ 100
-100 ≤ nums[i] ≤ 100
Follow-up: Can you solve this in O(n log n) time?

Visualization

Tap to expand

Understanding the Visualization

Count Everyone's Tickets

Survey all attendees to count their tickets - this is like building our frequency map

Apply Sorting Rules

People with fewer tickets go first, but among those with same ticket count, higher VIP numbers go first

Arrange the Line

Use the ticket count information to efficiently sort everyone according to the rules

Key Takeaway

🎯 Key Insight: By counting frequencies first, we avoid recalculating them during every comparison, reducing time complexity from O(n³) to O(n log n).

Asked in

a Amazon 15 f Facebook 12 Apple 8 G Google 6

The optimal solution uses a two-pass hash table approach: first count frequencies of each element, then sort using a custom comparator that references the frequency map. This achieves O(n log n) time complexity and O(n) space complexity, avoiding the repeated frequency calculations of the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Count During Each Comparison)	O(n³)	O(1)	Count frequency of each element every time we need to compare two elements
Two-Pass Hash Table (Optimal)	O(n log n)	O(n)	Count frequencies first, then sort using custom comparator

Brute Force (Count During Each Comparison) — Algorithm Steps

Use a simple sorting algorithm like bubble sort
For each comparison, count frequency of both elements by scanning the array
Compare based on frequency (ascending), then by value (descending)
Repeat until array is sorted

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare first two elements

Scan entire array to count frequency of each element

Continue comparisons

For each new comparison, scan array again to count frequencies

Repeat process

This leads to O(n³) time complexity due to repeated counting

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 frequencySort(int* nums, int size) {
    int* original = (int*)malloc(size * sizeof(int));
    memcpy(original, nums, size * sizeof(int));
    
    // Bubble sort with custom comparison
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            int freqJ = countFrequency(original, size, nums[j]);
            int freqJ1 = countFrequency(original, size, nums[j + 1]);
            
            int shouldSwap = 0;
            if (freqJ > freqJ1) {
                shouldSwap = 1;
            } else if (freqJ == freqJ1 && nums[j] < nums[j + 1]) {
                shouldSwap = 1;
            }
            
            if (shouldSwap) {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
    }
    
    free(original);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100];
    int size = 0;
    
    char* token = strtok(input, "[,] \n");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,] \n");
    }
    
    frequencySort(nums, size);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", nums[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) comparisons for sorting, each comparison takes O(n) to count frequencies

⚠ Quadratic Growth

Space Complexity

O(1)

No additional data structures needed, sorting in place

✓ Linear Space

87.5K Views

Medium Frequency

~15 min Avg. Time

2.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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Count During Each Comparison) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler