Descripción del Título:
Dada una cadena, ordene los caracteres en la cadena en orden descendente de frecuencia de aparición.
Ejemplo 1:
Entrada: "árbol"
Salida: "eert"
Explicación:
'e' aparece dos veces, y 'r' y't 'solo aparecen una vez.
Por lo tanto, 'e' debe aparecer antes que 'r' y't '. Además, "eetr" también es una respuesta válida.
Ejemplo 2:
Entrada: "cccaaa"
Salida: "cccaaa"
Explicación:
Tanto 'c' como 'a' aparecen tres veces. Además, "aaaccc" también es una respuesta válida.
Tenga en cuenta que "cacaca" es incorrecto, porque se deben juntar las mismas letras.
Ejemplo 3:
Entrada: "Aabb"
Salida: "bbAa"
Explicación:
Además, "bbaA" también es una respuesta válida, pero "Aabb" es incorrecta.
Tenga en cuenta que'A 'y'a' se consideran dos caracteres diferentes.
el código se muestra a continuación:
Tabla de picadillo:
class Solution {
public String frequencySort(String s) {
int n = s.length();
HashMap<Character, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) {
map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
}
List<Map.Entry<Character, Integer>> list = new LinkedList<>(map.entrySet());
list.sort(new Comparator<Map.Entry<Character, Integer>>() {
@Override
public int compare(Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2) {
return o2.getValue() - o1.getValue();
}
});
StringBuilder sb = new StringBuilder();
for (Map.Entry<Character, Integer> entry : list) {
sb.append(String.valueOf(entry.getKey()).repeat(Math.max(0, entry.getValue())));
}
return sb.toString();
}
}
Clasificación de cubos:
class Solution {
public String frequencySort(String s) {
if (s.isEmpty() || s.length() == 1) {
return s;
}
// 构造 HashMap。Key:s 中的每个元素;Value:对应元素出现的次数(即频率)
Map<Character, Integer> store = new HashMap<>();
for (char c : s.toCharArray()) {
// 填充 HashMap。如果当前 Key c 不存在,getOrDefault() 方法返回默认值 0;
// 否则返回当前 Key c 对应的 Value。
// 不管哪种情况最后都在 0 或者 Value 的基础上 +1。
store.put(c, store.getOrDefault(c, 0) + 1);
}
// 构造一个桶的集合(即一系列桶),桶的个数为 s 的长度 +1,因为 buckets[0] 没有意义
// 目的是将出现频率为 i 的字符放到第 i 个桶里(即 buckets[i])
List<Character>[] buckets = new List[s.length() + 1];
for (char key : store.keySet()) {
// 某个字符在 HashMap 中的 Value 是几就会被放到第几个桶里
int value = store.get(key);
if (buckets[value] == null) {
// 如果某个桶还未放入过字符(即未初始化),则初始化其为一个数组
buckets[value] = new ArrayList<Character>();
}
buckets[value].add(key); // 然后将字符放到桶中
}
StringBuilder res = new StringBuilder();
for (int i = buckets.length - 1; i > 0; --i) {
// 遍历每个桶
if (buckets[i] != null) {
// 如果桶里有字符
for (char j : buckets[i]) {
// 遍历桶里的每个字符
for (int k = i; k > 0; --k) {
// 字符出现了几次就向 res 中添加几次该字符
res.append(j);
}
}
}
}
return res.toString();
}
}
class Solution {
public String frequencySort(String s) {
int m = s.length();
if (m == 1 || m == 2 || m == 0) {
return s;
}
HashMap<Character, Integer> map = new HashMap<>();
for (int i = 0; i < m; i++) {
map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
}
List<Character>[] buckets = new ArrayList[m + 1];
for (var entry : map.entrySet()) {
int value = entry.getValue();
if (buckets[value] == null) {
buckets[value] = new ArrayList<Character>();
}
buckets[value].add(entry.getKey());
}
StringBuilder sb = new StringBuilder();
for (int i = buckets.length - 1; i > 0; --i) {
if (buckets[i] != null) {
for (char j : buckets[i]) {
sb.append(String.valueOf(j).repeat(i));
}
}
}
return sb.toString();
}
}
Resultados del: