C语言——txt词频统计

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXKEY 2000
#define MAX_WORD_SIZE 30

int hash(char *key) {
    int h = 0, g;
    while (*key) {
        h = (h << 4) + *key++;
        g = h & 0xf0000000;
        if (g)
            h ^= g >> 24;
        h &= ~g;
    }
    return h % MAXKEY;
}

typedef struct data_count {
    int character_count;    //字符数
    int line_count;    //行数
    int word_count;    //单词数
}Data_c,*pData_c;

typedef struct words_info {
    char word[MAX_WORD_SIZE];    //单词内容
    int times;    //单词次数
    struct words_info *pNext;
}Word_t,*pWord_t;

//尾插输入单词
void tailInsert_hashtable_for_words(pWord_t *ppHead,pWord_t *ppTail,char words[]) {
    pWord_t pNew = (pWord_t)calloc(1, sizeof(Word_t));
    strcpy(pNew->word, words);
    if (*ppHead == NULL) {
        *ppHead = pNew;
        *ppTail = pNew;
    }
    else {
        (*ppTail)->pNext = pNew;
        (*ppTail) = pNew;
    }
}

//将单词放进哈希表的链表内，添加新节点或者加次数，用来解决哈希冲突
void putInHashTable(char word[], pWord_t pHashTable[]) {
    //哈希表对应位置为空，则单词不存在，添加单词
    int hashval = hash(word);
    //哈希表内对应hash值为空，添加节点
    if (pHashTable[hashval] == NULL) {
        pWord_t    pWordNode = (pWord_t)calloc(1, sizeof(Word_t));
        strcpy(pWordNode->word, word);
        pWordNode->times = 1;
        pHashTable[hashval] = pWordNode;
    }
    else {
        //遍历哈希表内对应hash值的链表，找到对应的单词
        pWord_t pTemp = pHashTable[hashval];
        while (pTemp->pNext != NULL) {
            if (!(strcmp(pTemp->word, word))) {
                pTemp->times++;
                return;
            }
            pTemp = pTemp->pNext;
        }
        //遍历链表没有对应单词，则末尾添加新节点
        pWord_t    pWordNode = (pWord_t)calloc(1, sizeof(Word_t));
        strcpy(pWordNode->word, word);
        pWordNode->times = 1;
        pTemp->pNext = pWordNode;
    }
}

int compare(const void *pleft, const void *pright) {
    Word_t *pL = (Word_t *)pleft;
    Word_t *pR = (Word_t *)pright;
    return pR->times - pL->times;
}

pWord_t createSortedWordsListFromHashTable(pWord_t pHashTable[]) {
    //如果要使用快排，就需要将哈希表的数据转换为连续存储的动态数组。 
    int countofWordList = 1;//输出的数组的容量
    int currentSize = 0;//当前数组的下标
    pWord_t wordList = (pWord_t)calloc(1, sizeof(Word_t));
    for (int i = 0; i < MAXKEY; i++) {
        //哈希表中为空，通过
        if (pHashTable[i] == NULL) {
            continue;
        }
        else {
            //遍历存储
            pWord_t pCur_InHashTable = pHashTable[i];
            while (pCur_InHashTable) {
                currentSize++;
                if (currentSize == countofWordList) {
                    countofWordList *= 2;
                    //数组扩容
                    wordList = (pWord_t)realloc(wordList, countofWordList *sizeof(Word_t));
                }
                strcpy(wordList[currentSize - 1].word, pCur_InHashTable->word);
                wordList[currentSize - 1].times = pCur_InHashTable->times;
                pCur_InHashTable = pCur_InHashTable->pNext;
            }
        }
    }
    qsort(wordList, currentSize, sizeof(Word_t), compare);
    return wordList;
}

void calculate_words(char *buf,int count,pData_c dataCount) {    //计算各种信息的个数
    pWord_t pHashTable[MAXKEY] = { NULL };
    int if_words = 1;        //判断是否是单词的标志位
    int start = 0, end = 0;            //单词的起始索引和最后字符的索引
    for (int i = 0; i < count; i++) {
        //计算字符个数，排除空格、\t、换行
        if (buf[i] != ' ' && buf[i] != '\t' &&buf[i] != '\n') {                
            dataCount->character_count++;
        }
        //计算行数，用'\n'\计算
        if (buf[i] == '\n') {                                            
            dataCount->line_count++;
        }
        //计算单词个数，非字母的后面有字母，则+1
        if (((buf[i] >= 'a'&&buf[i] <= 'z') || (buf[i] >= 'A'&&buf[i] <= 'Z'))) {
            if (if_words == 0) {
                start = i;
                if_words = 1;
                end = 0;
            }
        }
        else {
            if (if_words == 1){ 
                //此时字符由之前的字母转到到非字母，判断为一个单词
                dataCount->word_count++; 
                end = i;
                if_words = 0;
            }
            else {
                continue;
            }
        }

        //将单词记录进hashtable
        if ((start < end) && (if_words == 0)) {
            char temp[30];
            memcpy(temp, &buf[start], end - start);
            temp[end - start] = '\0';
            //大写转小写
            for (int i = 0; i < end - start; i++) {
                if (temp[i] >= 'A'&&temp[i] <= 'Z') {
                    temp[i] += 32;
                }
            }
            putInHashTable(temp,&pHashTable);
        }
    }
    pWord_t wordList = createSortedWordsListFromHashTable(pHashTable);
    for (int i = 0; i < 10; i++) {
        printf("词频第%d高的是%s,出现%d次。\n", i + 1, wordList[i].word, wordList[i].times);
    }
}

int main(int args,char* argv[]) {
    FILE *old_file = fopen(argv[1], "r");
    if (old_file == NULL) {
        printf("old_flie errno is %d\n", errno);
        perror("fopen:");
        return -1;
    }

    int count = 0;                                                                        //统计原文件的字符数，申请合适的buf空间            
    while (fgetc(old_file) != EOF) {
        count++;
    }
    char *buf = (char *)calloc(1,count * sizeof(char));

    fseek(old_file,0,SEEK_SET);                                                            //重置前面移动的oldfile指针
    fread(buf, 1, count, old_file);                                                        //将old_file的内容全部存进buf中

    Data_c *dataCount = (Data_c *)calloc(1,sizeof(Data_c));
    //这里统计字符个数，行数，单词个数
    calculate_words(buf,count,dataCount);
    fclose(old_file);
    printf("\n\n\nOutput ended.\n");
    printf("字符总计%d个，行数总计%d行，单词总计= %d个\n", dataCount->character_count, dataCount->line_count, dataCount->word_count);

    free(buf);
}