统计列表中元素的出现次数，本质上就是把元素值映射为对应的计数值。假设列表长度为 n，如果每遇到一个元素就调用列表的 count 方法重新扫描一遍，复杂度会达到 O(n²)。更合理的做法是维护一个哈希表，在单次遍历中完成计数：遇到新元素就初始化为 1，已经存在就将计数值加 1。之后只需要对哈希表中的键值对按计数值排序即可。整个流程看似简单，但排序稳定性、语言内置工具的选择、特殊值处理都会影响最终结果。

一、哈希表遍历：把计数复杂度降到线性

如果直接使用列表自带的 count 方法，每处理一个元素都要重新遍历整个列表，总复杂度是 O(n²)。当列表长度为 10 万时，最坏情况下需要执行约 100 亿次比较，这显然不可接受。哈希表的优势在于，键的查找和更新操作平均时间复杂度是 O(1)，因此只需要一次遍历就可以完成所有计数。

Python 标准库中的 Counter 是专门为计数场景设计的 dict 子类，它内部做了大量优化，用起来非常简洁。

from collections import Counter
items = ["apple", "banana", "apple", "cherry", "banana", "apple"]
freq = Counter(items)
print(freq)
# Counter({'apple': 3, 'banana': 2, 'cherry': 1})

如果不使用 Counter，也可以用普通字典配合 get 方法实现同样的效果。这样写的好处是兼容更早的 Python 版本，也让计数逻辑更透明。

freq = {}
for item in items:
    freq[item] = freq.get(item, 0) + 1
print(freq)
# {'apple': 3, 'banana': 2, 'cherry': 1}

Java 中通常使用 HashMap 来完成这项工作，getOrDefault 方法可以让代码少写一层条件判断。虽然 Java 的包装类型会带来一定装箱开销，但整体复杂度仍然是线性的。

import java.util.*;
List<String> items = Arrays.asList("apple", "banana", "apple", "cherry", "banana", "apple");
Map<String, Integer> freq = new HashMap<>();
for (String item : items) {
    freq.put(item, freq.getOrDefault(item, 0) + 1);
}
System.out.println(freq);

JavaScript 在没有 Map 之前，经常用普通对象做频率统计，但普通对象的键只能是字符串或 Symbol，如果不是字符串类型会被强制转换，容易产生意外结果。现代 JavaScript 中推荐使用 Map，它可以保留任意类型的键。

const items = ["apple", "banana", "apple", "cherry", "banana", "apple"];
const freqMap = new Map();
for (const item of items) {
  freqMap.set(item, (freqMap.get(item) || 0) + 1);
}
console.log(freqMap);
// Map(3) { 'apple' => 3, 'banana' => 2, 'cherry' => 1 }

这里要注意，Map 和普通对象在键比较策略上有差异。普通对象会把数字键和字符串键混在一起比较，而 Map 使用同一性比较，键类型不同时不会互相覆盖。例如数字 1 和字符串 "1" 在对象中会合并，但在 Map 中是两个独立键。

二、按频率排序：稳定性和复合键设计

得到频率字典或频率映射后，下一步就是排序。很多人会直接使用语言的默认排序，但字典默认排序往往不是按值，而是按键。以 Python 为例，sorted(freq.items()) 默认按键升序排列，结果可能完全不符合频率排序的预期。必须通过 key 参数指定排序依据。

Python 中可以使用 sorted 搭配 lambda 表达式。如果只写 key=lambda item: item[1]，默认是升序排列，频率低的会排在前面。为了得到频率从高到低的结果，可以在计数值前加负号。

sorted_items = sorted(freq.items(), key=lambda item: (-item[1], item[0]))
print(sorted_items)
# [('apple', 3), ('banana', 2), ('cherry', 1)]

这里的复合键 (-item[1], item[0]) 有两层含义：先按计数值的相反数降序排列，再按键名升序排列。这样做的好处是，当多个元素频率相同时，排序结果仍然是确定的、可复现的，不会因为哈希表的内部顺序变化而出现随机结果。

Java 中可以利用 Comparator 的链式写法来实现同样的复合排序。先将 Map.Entry 集合转成 List，再调用 sort 方法。

List<Map.Entry<String, Integer>> entries = new ArrayList<>(freq.entrySet());
entries.sort(
    Map.Entry.<String, Integer>comparingByValue()
        .reversed()
        .thenComparing(Map.Entry.comparingByKey())
);
for (Map.Entry<String, Integer> entry : entries) {
    System.out.println(entry.getKey() + ":" + entry.getValue());
}

这段代码先按值降序排列，再按键升序排列。虽然 Java 的 List.sort 本身是稳定排序，但显式指定第二排序键仍然是好习惯，因为它让排序规则不依赖底层实现的稳定性保证。

JavaScript 中需要先把 Map 转成数组，再使用 sort。比较函数中的 b[1] - a[1] 用于数值降序，如果差值为 0，则继续调用 localeCompare 对键做字符串升序比较。

const sorted = [...freqMap.entries()].sort((a, b) => {
  return b[1] - a[1] || a[0].localeCompare(b[0]);
});
console.log(sorted);

如果只关心出现次数最多的前几个元素，比如 Top 3，那么全量排序其实有些浪费。Python 的 heapq.nlargest 可以只维护一个大小为 k 的堆，复杂度为 O(m log k)，在元素种类 m 很大而 k 很小时优势明显。

import heapq
top3 = heapq.nlargest(3, freq.items(), key=lambda x: x[1])
print(top3)
# [('apple', 3), ('banana', 2), ('cherry', 1)]

这种堆方案尤其适合海量数据的频率统计场景。比如一个日志文件包含上百万种不同的错误码，只需要找出出现次数最高的前 10 个，使用全量排序会消耗大量内存和时间，而堆只需要维护 10 个元素的大小。

三、特殊情况与可复用函数

真实业务中，元素并不总是干净的字符串或数字。比如在做词频统计时，大小写通常需要归一化，否则 Apple 和 apple 会被当成两个不同元素。Python 中可以在生成器表达式里直接处理，避免创建中间列表。

from collections import Counter
data = ["Apple", "apple", "Banana", "cherry", "banana"]
normalized_freq = Counter(item.lower() for item in data)
print(normalized_freq)
# Counter({'apple': 2, 'banana': 2, 'cherry': 1})

如果列表里包含列表、字典这类不可哈希对象，直接放进 Counter 会抛出 TypeError。解决办法是在统计前把不可哈希对象转换为可哈希的元组或其他稳定表示。

nested = [[1, 2], [1, 2], [3]]
freq = Counter(tuple(x) for x in nested)
print(freq)
# Counter({(1, 2): 2, (3,): 1})

需要注意的是，元组虽然可哈希，但如果内部元素仍然可变，哈希值虽然不变但内容可能被修改，这会导致字典行为异常。实际使用时最好保证转换后的键是不可变且唯一的。

Java 中可以封装一个泛型方法，让调用方传入任意类型的列表，并指定返回前几个高频元素。泛型方法需要考虑类型边界，这里用 <T> 表示任意引用类型，HashMap 和流式排序配合完成统计和排序。

import java.util.*;
import java.util.stream.Collectors;
public static <T> List<T> topFrequent(List<T> items, int limit) {
    Map<T, Integer> freq = new HashMap<>();
    for (T item : items) {
        freq.put(item, freq.getOrDefault(item, 0) + 1);
    }
    return freq.entrySet().stream()
        .sorted(Map.Entry.<T, Integer>comparingByValue().reversed())
        .limit(limit)
        .map(Map.Entry::getKey)
        .collect(Collectors.toList());
}

Python 的通用函数则可以更灵活地处理字符串归一化，同时通过 top_k 参数控制返回数量。这个函数可以很方便地复用到词频分析、投票统计、日志解析等常见任务中。

from collections import Counter
def count_and_sort(data, top_k=None):
    freq = Counter(
        item.lower() if isinstance(item, str) else item
        for item in data
    )
    sorted_items = sorted(freq.items(), key=lambda x: (-x[1], x[0]))
    if top_k is not None:
        return sorted_items[:top_k]
    return sorted_items
print(count_and_sort(["Apple", "apple", "banana", "cherry", "banana"], top_k=2))
# [('apple', 2), ('banana', 2)]

这段代码把字符串统一转成小写，对非字符串元素保持原样，然后使用复合排序键保证结果稳定。通过 top_k 参数可以在不需要全部频率数据时直接截取前 K 项，避免无意义的全量排序。