Sort Characters By Frequency - Practice Coding Problems

Sort Characters By Frequency - Problem

Hash Table String Sorting Heap (Priority Queue) Bucket Sort Counting Medium

Given a string s, your task is to rearrange its characters so they appear in decreasing order of frequency. In other words, characters that appear more often should come first in the result.

The frequency of a character is simply how many times it appears in the original string. If two characters have the same frequency, you can arrange them in any order relative to each other.

Example: If the input is "tree", the character 'e' appears 2 times, while 't' and 'r' each appear 1 time. So a valid output would be "eert" or "eetr".

Your goal is to return any valid string that satisfies the frequency sorting requirement.

Input & Output

example_1.py — Basic Case

$ Input: s = "tree"

› Output: "eetr" or "eert"

💡 Note: The character 'e' appears 2 times, while 't' and 'r' each appear 1 time. Since 'e' has the highest frequency, it comes first in the result.

example_2.py — Multiple Same Frequencies

$ Input: s = "cccaaa"

› Output: "cccaaa" or "aaaccc"

💡 Note: Both 'c' and 'a' appear 3 times each. Since they have the same frequency, either can come first in the result.

example_3.py — Single Character

$ Input: s = "Aab"

› Output: "bbA" or "bAb"

💡 Note: The character 'b' appears 1 time, 'A' appears 1 time, and 'a' appears 1 time. Any arrangement is valid since all frequencies are equal.

Visualization

Tap to expand

Understanding the Visualization

Count Song Plays

Go through listening history and count how many times each song was played

Create Popularity Buckets

Create buckets for each play count (1 play, 2 plays, 3 plays, etc.)

Group Songs by Popularity

Place each song in the bucket corresponding to its play count

Build Playlist

Start with highest play count bucket and add all songs, then move to lower counts

Key Takeaway

🎯 Key Insight: By using bucket sort instead of comparison-based sorting, we can reduce the time complexity from O(n + k log k) to O(n), making it optimal for this problem where the maximum frequency is bounded by the string length.

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to count frequencies + O(n) to fill buckets + O(n) to build result = O(n) total

✓ Linear Growth

Space Complexity

O(n)

O(k) for frequency map + O(n) for buckets array where n is string length

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 5 × 10⁵
s consists of uppercase and lowercase English letters and digits
Multiple valid answers exist - return any one of them

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 25 f Meta 22 Apple 18

The optimal solution uses bucket sort to achieve O(n) time complexity. First, count character frequencies using a hash map. Then, create buckets indexed by frequency (0 to n) and place characters in their corresponding frequency buckets. Finally, traverse buckets from highest to lowest frequency to build the result string. This avoids the O(k log k) sorting step required in the standard hash map approach.

Common Approaches

Approach	Time	Space	Notes
✓ Bucket Sort (Optimal)	O(n)	O(n)	Use bucket sort to avoid the sorting step and achieve optimal time complexity
Brute Force (Count Each Character Separately)	O(n² + k log k)	O(k)	For each unique character, scan the entire string to count its frequency
Hash Table + Sorting	O(n + k log k)	O(k)	Use hash map to count frequencies efficiently, then sort by frequency

Bucket Sort (Optimal) — Algorithm Steps

Count character frequencies using a hash map
Create buckets array where index represents frequency (0 to n)
Place characters into buckets based on their frequency
Traverse buckets from highest frequency to lowest
Build result string by adding characters from each bucket

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build frequency map: {t:1, r:1, e:2}

Create Buckets

Create buckets[0] to buckets[4] for frequencies 0 to n

Fill Buckets

Place characters in buckets: buckets[1]=['t','r'], buckets[2]=['e']

Traverse High to Low

Go from buckets[4] down to buckets[1], building result

Build Result

From buckets[2]: 'ee', from buckets[1]: 'tr' → 'eetr'

Code -

solution.c — C

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

#define MAX_CHARS 256

char* frequencySort(char* s) {
    int len = strlen(s);
    if (len == 0) return s;
    
    // Count frequencies
    int freq[MAX_CHARS] = {0};
    for (int i = 0; i < len; i++) {
        freq[(unsigned char)s[i]]++;
    }
    
    // Create buckets (simple approach using 2D array)
    char buckets[len + 1][MAX_CHARS];  // buckets[frequency][chars]
    int bucketSizes[len + 1];          // number of chars in each bucket
    memset(bucketSizes, 0, sizeof(bucketSizes));
    
    // Fill buckets
    for (int i = 0; i < MAX_CHARS; i++) {
        if (freq[i] > 0) {
            int f = freq[i];
            buckets[f][bucketSizes[f]] = (char)i;
            bucketSizes[f]++;
        }
    }
    
    // Build result from highest frequency to lowest
    int idx = 0;
    for (int f = len; f > 0; f--) {
        for (int i = 0; i < bucketSizes[f]; i++) {
            char ch = buckets[f][i];
            for (int j = 0; j < f; j++) {
                s[idx++] = ch;
            }
        }
    }
    
    return s;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    
    printf("%s\n", frequencySort(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to count frequencies + O(n) to fill buckets + O(n) to build result = O(n) total

✓ Linear Growth

Space Complexity

O(n)

O(k) for frequency map + O(n) for buckets array where n is string length

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 5 × 10⁵
s consists of uppercase and lowercase English letters and digits
Multiple valid answers exist - return any one of them

89.8K Views

Medium-High Frequency

~15 min Avg. Time

3.2K 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

Bucket Sort (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler