Sort a string according to the frequency of characters

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

// structure to hold frequency and character
typedef struct {
    int freq;
    char ch;
} CharFreq;

// returns count of a character in the string
int countFrequency(char s[], char ch) {
    int count = 0;
    int len = strlen(s);

    for (int i = 0; i < len; i++) {
        // check if current character matches ch
        if (s[i] == ch)
            ++count;
    }

    return count;
}

// comparator function for qsort
int compare(const void *a, const void *b) {
    CharFreq *x = (CharFreq *)a;
    CharFreq *y = (CharFreq *)b;
    return x->freq - y->freq;
}

// function to sort the string according to frequency
void frequencySort(char s[], char ans[]) {
    int n = strlen(s);

    // array to store frequency and corresponding character
    CharFreq arr[100];  // assume max length <= 100

    // insert frequency and character into the array
    for (int i = 0; i < n; i++) {
        arr[i].freq = countFrequency(s, s[i]);
        arr[i].ch = s[i];
    }

    // sort the array by frequency
    qsort(arr, n, sizeof(CharFreq), compare);

    // build the final answer string
    for (int i = 0; i < n; i++) {
        ans[i] = arr[i].ch;
    }
    ans[n] = '\0';  // null-terminate the result
}

int main() {
    char s[] = "geeksforgeeks";
    char ans[100];

    frequencySort(s, ans);
    printf("%s\n", ans);

    return 0;
}

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

// structure to hold frequency and character
typedef struct {
    int freq;
    char ch;
} CharFreq;

// comparator for sorting by frequency
int compare(const void* a, const void* b) {
    CharFreq* x = (CharFreq*)a;
    CharFreq* y = (CharFreq*)b;
    return x->freq - y->freq;
}

// function to sort the string according to frequency
void frequencySort(char s[]) {
    int n = strlen(s);

    // array to store frequency of lowercase letters
    int fre[26] = {0};
    for (int i = 0; i < n; i++) {
        fre[s[i] - 'a']++;
    }

    // create frequency-character array
    CharFreq vec[26];
    int size = 0;
    for (int i = 0; i < 26; i++) {
        if (fre[i] > 0) {
            vec[size].freq = fre[i];
            vec[size].ch = i + 'a';
            size++;
        }
    }

    // sort the array by frequency
    qsort(vec, size, sizeof(CharFreq), compare);

    // rebuild the string
    int idx = 0;
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < vec[i].freq; j++) {
            s[idx++] = vec[i].ch;
        }
    }
    s[idx] = '\0';  // null-terminate
}

int main() {
    char s[] = "geeksforgeeks";
    frequencySort(s);
    printf("%s\n", s);
    return 0;
}

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

#define MAX_CHAR 256

// structure to store frequency and character ASCII
typedef struct {
    int freq;
    int ch;
} CharFreq;

// function to swap two CharFreq elements
void swap(CharFreq* a, CharFreq* b) {
    CharFreq temp = *a;
    *a = *b;
    *b = temp;
}

// function to maintain min-heap property
void heapify(CharFreq heap[], int n, int i) {
    int smallest = i;
    int l = 2*i + 1;
    int r = 2*i + 2;

    // if frequency is same, use ASCII comparison
    if (l < n && (heap[l].freq < heap[smallest].freq ||
       (heap[l].freq == heap[smallest].freq && heap[l].ch < heap[smallest].ch))) {
        smallest = l;
    }

    if (r < n && (heap[r].freq < heap[smallest].freq ||
       (heap[r].freq == heap[smallest].freq && heap[r].ch < heap[smallest].ch))) {
        smallest = r;
    }

    if (smallest != i) {
        swap(&heap[i], &heap[smallest]);
        heapify(heap, n, smallest);
    }
}

// function to build a min-heap
void buildMinHeap(CharFreq heap[], int n) {
    for (int i = n/2 - 1; i >= 0; i--) {
        heapify(heap, n, i);
    }
}

// function to extract the min element from heap
CharFreq extractMin(CharFreq heap[], int* heapSize) {
    CharFreq min = heap[0];
    heap[0] = heap[*heapSize - 1];
    (*heapSize)--;
    heapify(heap, *heapSize, 0);
    return min;
}

// function to sort characters by frequency (ascending)
char* frequencySort(char* s) {
    int freqMap[MAX_CHAR] = {0};

    // count frequency
    for (int i = 0; s[i]; i++) {
        freqMap[(int)s[i]]++;
    }

    CharFreq heap[MAX_CHAR];
    int heapSize = 0;

    // fill heap array with non-zero frequency characters
    for (int i = 0; i < MAX_CHAR; i++) {
        if (freqMap[i]) {
            heap[heapSize].freq = freqMap[i];
            heap[heapSize].ch = i;
            heapSize++;
        }
    }

    // build the min-heap
    buildMinHeap(heap, heapSize);

    // create result string
    char* ans = (char*)malloc(strlen(s) + 1);
    int idx = 0;

    while (heapSize > 0) {
        CharFreq curr = extractMin(heap, &heapSize);
        for (int i = 0; i < curr.freq; i++) {
            ans[idx++] = (char)curr.ch;
        }
    }

    ans[idx] = '\0';
    return ans;
}

int main() {
    char s[] = "geeksforgeeks";
    char* res = frequencySort(s);
    printf("%s\n", res);
    free(res);
    return 0;
}