Codestin Search App

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.

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to count frequencies + O(n log n) for sorting with O(1) comparisons

⚡ Linearithmic

Space Complexity

O(n)

Hash map to store frequency of unique elements (worst case O(n) unique elements)

⚡ Linearithmic Space

Constraints

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

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
✓ 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)	O(n³)	O(1)	Count frequency of each element every time we need to compare two elements

Two-Pass Hash Table (Optimal) — Algorithm Steps

Create a hash map to count frequency of each element
Iterate through array once to populate frequency map
Sort array using custom comparator that uses the frequency map
Comparator sorts by frequency (ascending), then by value (descending)

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Frequency Map

Scan array once to count each element's frequency

Sort with Custom Comparator

Use frequency map for O(1) lookup during sorting

Return Sorted Array

Array is now sorted by frequency, then by value

Code -

solution.c — C

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

#define MAX_SIZE 1000
#define HASH_SIZE 2000

typedef struct {
    int value;
    int freq;
    int exists;
} FreqEntry;

FreqEntry freqMap[HASH_SIZE];

int hash(int key) {
    return (key + 1000) % HASH_SIZE; // Handle negative numbers
}

void addToFreqMap(int value) {
    int h = hash(value);
    while (freqMap[h].exists && freqMap[h].value != value) {
        h = (h + 1) % HASH_SIZE;
    }
    if (!freqMap[h].exists) {
        freqMap[h].value = value;
        freqMap[h].freq = 1;
        freqMap[h].exists = 1;
    } else {
        freqMap[h].freq++;
    }
}

int getFreq(int value) {
    int h = hash(value);
    while (freqMap[h].exists && freqMap[h].value != value) {
        h = (h + 1) % HASH_SIZE;
    }
    return freqMap[h].exists ? freqMap[h].freq : 0;
}

int compare(const void *a, const void *b) {
    int valA = *(int*)a;
    int valB = *(int*)b;
    int freqA = getFreq(valA);
    int freqB = getFreq(valB);
    
    if (freqA != freqB) {
        return freqA - freqB; // ascending by frequency
    }
    return valB - valA; // descending by value
}

void frequencySort(int* nums, int size) {
    // Initialize frequency map
    memset(freqMap, 0, sizeof(freqMap));
    
    // First pass: count frequencies
    for (int i = 0; i < size; i++) {
        addToFreqMap(nums[i]);
    }
    
    // Second pass: sort with custom comparator
    qsort(nums, size, sizeof(int), compare);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[MAX_SIZE];
    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 log n)

O(n) to count frequencies + O(n log n) for sorting with O(1) comparisons

⚡ Linearithmic

Space Complexity

O(n)

Hash map to store frequency of unique elements (worst case O(n) unique elements)

⚡ Linearithmic Space

Constraints

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler