C语言编程【问题描述】 编写程序统计一个英文文本文件中每个单词的出现次数（词频统计），并将统计结果按单词出现频率 由高至低输出到指定文件中。

这是一个比较典型的文本处理问题，需要进行字符串的分割和哈希表的统计。具体思路如下：

1. 打开输入文件和输出文件，读取输入文件中的内容。

2. 对输入文件中的内容进行分割，将每个单词存储到哈希表中，并统计每个单词的出现次数。

3. 对哈希表中的单词按照出现频率从高到低进行排序。

4. 将排序后的结果输出到指定文件中。

以下是对应的 C 语言代码实现：

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

#define MAX_LINE 1024
#define MAX_WORD 128
#define MAX_HASH 10007

typedef struct WordNode {
    char* word;
    int count;
    struct WordNode* next;
} WordNode;

WordNode* hashTable[MAX_HASH] = { NULL };

// 哈希函数
unsigned int hash(char* str) {
    unsigned int hash = 0;
    while (*str) {
        hash = hash * 31 + (*str++);
    }
    return hash % MAX_HASH;
}

// 插入单词到哈希表中
void insert(char* word) {
    unsigned int key = hash(word);
    WordNode* node = hashTable[key];
    while (node != NULL) {
        if (strcmp(node->word, word) == 0) {
            node->count++;
            return;
        }
        node = node->next;
    }
    node = (WordNode*)malloc(sizeof(WordNode));
    node->word = (char*)malloc(strlen(word) + 1);
    strcpy(node->word, word);
    node->count = 1;
    node->next = hashTable[key];
    hashTable[key] = node;
}

// 释放哈希表中的内存
void freeHashTable() {
    for (int i = 0; i < MAX_HASH; i++) {
        WordNode* node = hashTable[i];
        while (node != NULL) {
            WordNode* next = node->next;
            free(node->word);
            free(node);
            node = next;
        }
    }
}

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

int main() {
    char inputFileName[MAX_WORD], outputFileName[MAX_WORD];
    printf("Input file name: ");
    scanf("%s", inputFileName);
    printf("Output file name: ");
    scanf("%s", outputFileName);

    FILE* inputFile = fopen(inputFileName, "r");
    if (inputFile == NULL) {
        printf("Failed to open input file.\n");
        return 1;
    }

    char line[MAX_LINE];
    while (fgets(line, MAX_LINE, inputFile)) {
        char* word = strtok(line, " \t\n\r\f.,:;?!()");
        while (word != NULL) {
            insert(word);
            word = strtok(NULL, " \t\n\r\f.,:;?!()");
        }
    }

    fclose(inputFile);

    WordNode* wordList[MAX_HASH];
    int count = 0;
    for (int i = 0; i < MAX_HASH; i++) {
        WordNode* node = hashTable[i];
        while (node != NULL) {
            wordList[count++] = node;
            node = node->next;
        }
    }

    qsort(wordList, count, sizeof(WordNode*), compare);

    FILE* outputFile = fopen(outputFileName, "w");
    if (outputFile == NULL) {
        printf("Failed to open output file.\n");
        freeHashTable();
        return 1;
    }

    for (int i = 0; i < count; i++) {
        fprintf(outputFile, "%s %d\n", wordList[i]->word, wordList[i]->count);
    }

    fclose(outputFile);

    freeHashTable();

    return 0;
}

需要注意的是，这里使用了链表法来解决哈希冲突，同时也需要在程序结束之后释放哈希表中的内存。另外，为了方便起见，这里使用了标准库中的快速排序函数 qsort 来对单词按照出现频率进行排序。