返回目录

给定一个1G大小的文件，每行1个单词，统计出现次数最多的前n个单词及数量

Python源码

from collections import defaultdict

# 读取文件并统计单词出现次数
word_count = defaultdict(int)
with open("file", "r") as file:
    for line in file:
        words = line.strip().lower().split()
        for word in words:
            word_count[word] += 1

# 排序并输出前10个出现次数最多的单词
sorted_word_count = sorted(word_count.items(), key=lambda x: x[1], reverse=True)
for word, count in sorted_word_count[:10]:
    print(f"{word}: {count}")

C语言源码

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

#define MAX_WORD_LENGTH 100

// 结构体用于存储单词及其出现次数
typedef struct {
    char word[MAX_WORD_LENGTH];
    int count;
} WordCount;

// 比较函数，用于排序
int compare(const void *a, const void *b) {
    return ((WordCount *)b)->count - ((WordCount *)a)->count;
}

int main() {
    FILE *file = fopen("file", "r");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }

    // 创建哈希映射来存储单词及其出现次数
    WordCount map[1000]; // 假设文件中最多有1000个不同的单词
    int mapSize = 0;

    // 读取文件中的每个单词并统计出现次数
    char word[MAX_WORD_LENGTH];
    while (fscanf(file, "%s", word) != EOF) {
        int found = 0;
        // 查找当前单词是否已在哈希映射中
        for (int i = 0; i < mapSize; i++) {
            if (strcmp(map[i].word, word) == 0) {
                map[i].count++;
                found = 1;
                break;
            }
        }
        // 如果未找到当前单词，则添加到哈希映射中
        if (!found) {
            strcpy(map[mapSize].word, word);
            map[mapSize].count = 1;
            mapSize++;
        }
    }
    fclose(file);

    // 对哈希映射按出现次数进行排序
    qsort(map, mapSize, sizeof(WordCount), compare);

    // 统计并输出前10个出现次数最多的单词
    for (int i = 0; i < mapSize && i < 10; i++) {
        printf("%s: %d\n", map[i].word, map[i].count);
    }

    return 0;
}

Java源码

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        // 读取文件
        BufferedReader reader = new BufferedReader(new FileReader("file"));
        // 创建哈希映射来存储单词及其出现次数
        HashMap<String, Integer> map = new HashMap<>();
    
        // 读取文件中的每个单词并统计出现次数
        String word = reader.readLine().trim().toLowerCase();
        while (word != null && word.length() > 0) {
            map.put(word, map.getOrDefault(word, 0) + 1);
            word = reader.readLine();
        }
        reader.close();
    
        // 获取哈希映射中的键值对，并按值排序
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        entries.stream().sorted(new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return o2.getValue() - o1.getValue();
            }
        });
    
        // 将排序后的键值对存入列表
        List<Map.Entry<String, Integer>> list = new ArrayList<>(entries);
    
        // 统计并输出前10个出现次数最多的单词
        for (int i = 0; i < list.size() && i < 10; i++) {
            Map.Entry<String, Integer> entry = list.get(i);
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }
}