451. 根据字符出现频率排序

451. 根据字符出现频率排序

给定一个字符串 s ，根据字符出现的 频率 对其进行 降序排序 。一个字符出现的 频率 是它出现在字符串中的次数。
返回 已排序的字符串 。如果有多个答案，返回其中任何一个。

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

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

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

---

C代码1：

typedef struct  {
    char key;
    int val;
    UT_hash_handle hh;
} HashTable;

HashTable* head;

void addHash(char* s) {
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        HashTable* tmp = NULL; 
        HASH_FIND(hh, head, &s[i], sizeof(char), tmp);  // hashTable tmp都是指针，查找传入地址&s[i](给地址去查找)
        if (tmp == NULL) {
            tmp = malloc(sizeof(HashTable));
            tmp->key = s[i];
            tmp->val = 1;
            HASH_ADD(hh, head, key, sizeof(char), tmp); 
        } else {
            tmp->val++;
        }
    }
}

int cmp(HashTable* a, HashTable* b) {
    return b->val - a->val;
}

char* frequencySort(char* s) {
    head = NULL;
    addHash(s);

    HASH_SORT(head, cmp);

    int retSize = 0;
    HashTable *cur, *next;
    HASH_ITER(hh, head, cur, next) {  // HASH_ITER遍历
        retSize += cur->val;  // 求输出数组长度
    }

    char* ret = malloc(sizeof(char) * (retSize + 1));  // 创建内存
    retSize = 0;
    HASH_ITER(hh, head, cur, next) {  // HASH_ITER遍历
        for (int i = 0; i < cur->val; i++) {
            ret[retSize++] = cur->key; 
        }
    }
    
    ret[retSize] = '\0';
    return ret;
}

---

Java代码1：按照出现频率排序

public String frequencySort(String s) {
    Map<Character, Integer> map = new HashMap<>();
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        map.put(c, map.getOrDefault(c, 0) + 1);
    }
    List<Character> list = new ArrayList<>(map.keySet());  // 把keySet传入链表中
    Collections.sort(list, (a, b) -> map.get(a).compareTo(map.get(b)));  // 根据map的value值 排序key值
    
    // Collections.sort(list, (a, b) -> map.get(b) - map.get(a));
    StringBuffer strb = new StringBuffer();
    for (int i = 0; i < list.size(); i++) {
        char c = list.get(i);  // 获得排序后的key值
        int n = map.get(c);    // 从map中取value值
        for (int j = 0; j < n; j++) {
            strb.append(c);
        }
    }
    return strb.toString();
}

---

Map排序：

Map<Integer, Integer> map = new HashMap();
for(int i = 0; i < len; ++i) {
	map.put(nums[i], i);
}
// 对Map进行排序，先放入到list当中，<>中放入类型
List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());

// lambda 形式
Collections.sort(list, (o1, o2) -> o2.getValue().compareTo(o1.getValue()));

//Collections.sort(list, (o1, o2) -> o2.getValue() - o1.getValue());  // IDEA中需要配置才能运行

Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>()) {
	@Override
	public int compare(Map.Entry<Integer,Integer> o1, Map.Entry<Integer,Integer> o2) {
	    return o2.getValue().compareTo(o1.getValue());  // 根据value值进降序排序
	}                                                   // 排序的依据和 被排序的内容是可以分开的
});
for (Map.Entry<Integer, Integer> entry : list) {
	...
}

---

算法图：

Java代码2：桶排序

public String frequencySort(String s) {
    Map<Character, Integer> map = new HashMap<Character, Integer>();
    int maxFreq = 0;
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        int freq = map.getOrDefault(c, 0) + 1;
        map.put(c, freq);
        maxFreq = Math.max(maxFreq, freq);
    }
    StringBuffer[] buckets = new StringBuffer[maxFreq + 1];
    for (int i = 0; i <= maxFreq; i++) {
        buckets[i] = new StringBuffer();
    }
    for (Map.Entry<Character, Integer> entry : map.entrySet()) {
        char c = entry.getKey();
        int freq = entry.getValue();
        buckets[freq].append(c);  // 桶的下标 = 桶中字符出现的次数
    }
    StringBuffer sb = new StringBuffer();
    for (int i = maxFreq; i > 0; i--) {  // 遍历桶、遍历出现的次数
        StringBuffer bucket = buckets[i];
        for (int j = 0; j < bucket.length(); j++) { // 遍历每个桶中的字符
            for (int k = 0; k < i; k++) {  // 桶的下标 = 桶中字符出现的次数
                sb.append(bucket.charAt(j));
            }
        }
    }
    return sb.toString();
}
// map： 统计每个字符出现的次数，
// buckets[i]：统计出现i次的有哪些字符；桶的下标 = 桶中字符出现的次数