[LeetCode] 451.根据字符出现频率排序（Medium）C语言题解

题目

• 给定一个字符串，请将字符串里的字符按照出现的频率降序排列。

---

示例

①示例1

• 输入: “tree”
• 输出: “eert”
• 解释: 'e’出现两次，'r’和’t’都只出现一次。
  | 因此’e’必须出现在’r’和’t’之前。此外，"eetr"也是一个有效的答案。

②示例2

• 输入: “cccaaa”
• 输出: “cccaaa”
• 解释: 'c’和’a’都出现三次。此外，"aaaccc"也是有效的答案。
  | 注意"cacaca"是不正确的，因为相同的字母必须放在一起。

③示例3

• 输入: “Aabb”
• 输出: “bbAa”
• 解释: 此外，"bbaA"也是一个有效的答案，但"Aabb"是不正确的。
  | 注意’A’和’a’被认为是两种不同的字符。

---

说明

①数据范围(自测)

• 0 <= s[i] < 128

②相关话题

• 哈希表
• 堆
• 排序
• 字符串

③相似题目

• 347. 前K个高频元素 — 力扣网
• 347. Top K Frequent Elements — leetcode
• 387. 字符串中的第一个唯一字符 — 力扣网
• 387. First Unique Character in a String — leetcode

④题目地址

• 451. 根据字符出现频率排序 — 力扣网
• 451. Sort Characters By Frequency — leetcode

---

解题方法

①哈希表 + 排序

• 数据的范围大概是 0 ~ 128，可用数组模拟的哈希表求解，速度最快(用空间换时间)。
• 用哈希表记录每个字符出现的次数，然后新建一个二维整型数组，第一列记录具体字符的ASC②码，第二列记录字符的出现次数，一一对应。
• 然后将出现次数从大到小排序，以便将字符串里的字符按照出现的频率降序排列。
• 时间复杂度：O(Nlogn)。
• 空间复杂度：O(N)。

②哈希表 + 字符数组

• 用哈希表记录每个字符出现的次数，然后新建一个二维字符数组，其行下标对应字符的出现次数，行字符串记录 出现次数 == 行下标 的字符总和，这样就可以"间接"对出现次数进行排序，降低了时间复杂度。
• 时间复杂度：O(N)。
• 空间复杂度：O(N)。(爆炸…)

ps：用这种方法折腾了好久…，结果发现空间复杂度太高，不能通过测试。修改了好久代码勉强通过提交后，又发现运行速度变得很慢，还不如暴力求解…

③哈希表(uthash)

• 用数组模拟的哈希表求解虽然直观，但是会浪费一些内存空间，所以更好的方法是使用 uthash。
• uthash 是一个用 C 语言编写的开源库，使用宏实现了哈希表的增删改查等功能。
• 用 uthash 统计不同字符的出现次数，然后使用其自带的排序功能将键值(字符)按照出现次数排序，最后遍历哈希表即可。
• 时间复杂度：O(N)。
• 空间复杂度：O(N)。

---

代码详解

• 哈希表 + 排序

// 快排函数(降序)。
// 注意:只需要排序arr[i][0](代表不同字符出现的次数)。
int compare(const void* a, const void* b) {
    return ((int*)b)[0]-((int*)a)[0]; 
}

char* frequencySort(char* s) {
    int hash[128] = {0}, arr[128][2] = {0}, len = strlen(s), size = 0;
   
    // 哈希表。
    for (int i = 0; i < len; i++) 
        hash[s[i]]++;
    for (int i = 0; i < 128; i++) {
        // 记录所有出现过的字母及其出现次数。
        if (hash[i] > 0) {
            arr[size][0] = hash[i];
            arr[size][1] = i;
            size++;
        }
    }
         
    // 对出现次数进行排序。
    qsort(arr, size, sizeof(arr[0]), compare);
    
    // 拼接字符串。
    for (int i = 0, j = 0; i < size; i++) {
        if (arr[i][0] > 0) {
            s[j++] = arr[i][1];
            arr[i][0]--;
            i--;
        }
    }
    
    return s;
}

• 哈希表 + 字符数组

char* frequencySort(char* s) {
    int hash[128] = {0}, len = strlen(s);
    char** arr = malloc(sizeof(char*)*(len+1));
    
    // 哈希表。
    for (int i = 0; i < len; i++) {
        hash[s[i]]++;
        arr[i] = malloc(sizeof(char)*1);   
        strcpy(arr[i], "");
    }
    
    arr[len] = malloc(sizeof(char)*1);
    strcpy(arr[len], "");
    strcpy(s, "");

    for (int i = 0; i < 128; i++) {
        if (hash[i] > 0) {
            int count = hash[i], l = strlen(arr[hash[i]]);
            char* s1 = malloc(sizeof(char)*(len+1));
            // 字符转字符串。
            char s2[2];
            s2[0] = i;
            s2[1] = '\0';
            
            if (strcmp(arr[hash[i]], "") == 0) {
                arr[hash[i]] = malloc(sizeof(char)*(count+1));
                strcpy(arr[hash[i]], "");
            }
            // 若多个字符出现次数相同。
            else {
                strcpy(s1, arr[hash[i]]);
                arr[hash[i]] = malloc(sizeof(char)*(count+l+1));
                strcpy(arr[hash[i]], s1);
            }
            
            // 拼接相同字符。
            while (count > 0) {
                strcat(arr[hash[i]], s2);             
                count--;
            }
        }
    }
    // 拼接字符串。
    for (int i = len; i > 0; i--) {
        if (strlen(arr[i]) > 0)
            strcat(s, arr[i]);
    }
    
    return s;
}

• 哈希表(uthash)

// uthash是一个用c语言编写的开源库，使用宏实现了哈希表的增删改查等功能。
struct hash {
    int key;
    int count;
    UT_hash_handle hh; 
};

// 降序排列。
int count_sort(struct hash* a, struct hash* b) {
    return b->count - a->count;
}

char* frequencySort(char* s) { 
    struct hash* hashTable = NULL;
    int len = strlen(s);
    char* result = malloc(sizeof(char)*(len+1));
    strcpy(result, "");
    
    // 用哈希表统计不同字符的出现次数。
    for (int i = 0; i < len; i++) {
        struct hash* h;
        int n = s[i];
        HASH_FIND_INT(hashTable, &n, h);
        
        if (!h) {
            h = malloc(sizeof(struct hash));
            h->key = s[i];
            h->count = 1;
            HASH_ADD_INT(hashTable, key, h);
        }
        else
            h->count++;
    }
    
    // 按出现次数排序键值(字符)。
    HASH_SORT(hashTable, count_sort);
    
    // 遍历排序后的哈希表。
    for (struct hash* s = hashTable; s != NULL; s = s->hh.next) {
        while (s->count > 0) {
            char s1[2];
            s1[0] = s->key;
            s1[1] = '\0';
            strcat(result, s1);
            s->count--;
        }
    }
    
    return result;
}

---

附录

• 我的个人博客：messi1002.top
• 如有错误或疑惑之处 请联系 wjymessi@163.com
• 所有题目解答：fork me on github