个人作业——词频统计

                                                             个人作业
                                                       ——词频统计

一、项目概况

       对源文件（*.txt,*.cpp,*.h,*.cs,*.html,*.js,*.java,*.py,*.php等，文件夹内的所有文件）统计字符数、单词数、行数、词频，统计结果以指定格式输出到默认文件中，以及其他扩展功能，并能够快速处理多个文件。

 

二、需求分析

（1）基本功能

a) 统计文件的字符数；

b) 统计文件的单词总数；

c) 统计文件的总行数；

d) 统计文件中各单词的出现次数，输出频率最高的10个；

e) 对给定文件夹及其递归子文件夹下的所有文件进行统计；

f) 统计两个单词（词组）在一起的频率，输出频率最高的前10个；

g) 在Linux系统下，进行性能分析，过程写到blog中（附加题）。

（2）输入与输出要求

a) 输入以命令行参数传入（文件夹的路径）；

b) 在当前路径输出最终结果文件result.txt。

三、功能模块与设计

（1）遍历文件夹

a）windows平台上使用 _finddata_t 结构体，及 _findfirst 和 _findnext等函数来查找文件并遍历子文件夹，linuc平台上进行适当移植，使用dirent结构体，opendir、readdir等函数来遍历；

b）采用深度优先搜索，判断是文件夹则遍历该文件夹，是文件则进行计数。

（2）统计文件中的字符、单词数、行数

a）用fgetc（）读取字符，ASCII码值≥32且<=126则计数加一；

b）行数目前是每个文件换行符数目+1；

c）单词数先用字符数组记录两个分隔符之间的所有字符（字母/数字），再判断是否符合单词定义，符合则计数加一。

（3）统计各单词、词组出现频率

a）用两个哈希表来进行查找计数，哈希函数采用ELFhash函数，采用开散列法（拉链法）；

b）单词结构体包括次数、单词（同类则保存ASCII码最小的那个）、除去单词最末尾的数字剩下部分的小写（便于判断是否属于同一单词）；

c）词组结构体包括次数、两个单词的指针；

（4）对单词、词组出现频率进行排序，各找出前十个并输出

a）目前采用的是最简单的一个方法，用一个容量为10的数组，对全部单词、词组一次遍历，依次数组内容比较，最后数组保留的即为最大的10个。

四、代码实现

（1）遍历文件夹

1）windows平台

a）main函数判断命令行参数是否符合要求

if (argc != 2)
{
    printf("one folderpath required!\n");
    exit(1);
}

b）判断是文件还是文件夹

_finddata_t fileInfo;
long Handle = _findfirst(argv[1], &fileInfo);

if (Handle != -1L && (fileInfo.attrib & _A_SUBDIR) == 0)
{
    //It's a file name and not a folder path 
    CountQuantity(argv[1]);
}
else
{    
    //it's a folder path
    TraverseFolder(argv[1]);
}

c）递归遍历文件夹

头文件：#include<io.h>

函数原型：void TraverseFolder(string folderPath) ；

void TraverseFolder(string folderPath)
{
    //Traverse a folder using Depth First Search Traversal
    if (folderPath.empty())
    {
        printf("The folder path is empty!\n");
        exit(0);
    }

    _finddata_t fileInfo;
    string filePath;
    filePath = folderPath + "\\*";

    long Handle = _findfirst(filePath.c_str(), &fileInfo);

    if (Handle == -1L)
    {
        printf("cannot match the folder path %s\n", filePath.c_str());
        //printf("cannot match the folder path %s\n", filePath);
        return;
    }
    do
    {
        //Judge if there are subdirectories
        if (fileInfo.attrib & _A_SUBDIR)
        {
            //Exclude two cases
            if ((strcmp(fileInfo.name, ".") != 0) && (strcmp(fileInfo.name, "..") != 0))
            {
                //Traverse subdirectories
                string newPath;
                newPath = folderPath + "\\" + fileInfo.name;
                TraverseFolder(newPath);
            }
        }
        else
        {
            string fullName;
            fullName = folderPath + "\\" + fileInfo.name;
            CountQuantity(fullName.c_str());
        }
    } while (_findnext(Handle, &fileInfo) == 0);

    _findclose(Handle);
}

2）linux平台

a）main函数判断命令行参数是否符合要求

if (argc != 2)
{
    printf("one dir required!\n");
    exit(1);
}

b)递归遍历文件夹

头文件：#include<dirent.h>

函数原型：void TraverseFolder(string folderPath) ；

void TraverseFolder(string folderPath)
{
    //Traverse a folder using Depth First Search Traversal
    if (folderPath.empty())
    {
        printf("The folder path is empty!\n");
        exit(0);
    }
    
    DIR *dir;
    struct dirent *ptr;

    if ((dir = opendir(folderPath.c_str())) == NULL)
    {
        printf("cannot match the folder path %s\n", folderPath.c_str());
        return;
    }
    while((ptr = readdir(dir)) != NULL)
    {
        //Judge if there are subdirectories
        if (ptr->d_type & DT_DIR)
        {
            //Exclude two cases
            if ((strcmp(ptr->d_name, ".") != 0) && (strcmp(ptr->d_name, "..") != 0))
            {
                //Traverse subdirectories
                string newPath;
                newPath = folderPath + "/" + ptr->d_name;
                TraverseFolder(newPath);

            }
        }
        else
        {
            string fullName;
            fullName = folderPath + "/" + ptr->d_name;
            CountQuantity(fullName.c_str());
        }
    }

    closedir(dir);
}

 注意：linux系统下，代码中文件路径只能用斜杠“/”来表示，而windows下用“/”和“\\”均可。

（2）字符数、行数、单词数计数

函数原型：void CountQuantity(const char* fileName)；//传入文件名

void CountQuantity(const char* fileName) 
{    
    //Count the total number of characters/lines/words
    FILE *fp = NULL;
    char ch;
    char tempWord[WORD_MAX_LENGTH];//for preserving word temprorily
    wordList wNode, wNodePre = NULL;
    int i = 0, j = 0, flag = 0;

    if ((fp = fopen(fileName, "r")) == NULL) {
        printf("cannot open this file %s\n", fileName);
        exit(0);
    }

    while ( (ch = fgetc(fp)) != EOF)
    {    
        if(ch >= 32 && ch <= 126)
            characterNum++;
        if (ch == '\n') 
        {
            lineNum++;
        }
        if (isLetter(ch) || isNumber(ch))
        {
            i = 0;
            tempWord[i++] = ch;
            while ((ch = fgetc(fp)) != EOF && (isLetter(ch) || isNumber(ch)))
            {
                characterNum++;
                tempWord[i++] = ch;
            }
            tempWord[i] = '\0';

            if (i >= 4 && i <= 1024  && isLetter(tempWord[0]) && isLetter(tempWord[1]) && isLetter(tempWord[2]) && isLetter(tempWord[3]))
            {
                // it's a word
                wordNum++;
                for (j = i - 1; isNumber(tempWord[j]); j--)
                {
                }
                wNode = CountFrequency(tempWord, j + 1);
                if (flag == 1)
                {
                    CountFrequency_Phrase(wNodePre,wNode);
                }
                wNodePre = wNode;
                flag = 1;
            }
            if (ch >= 32 && ch <= 126)
                characterNum++;
            if (ch == '\n')
            {
                lineNum++;
            }
            if (ch == EOF)
            {
                break;
            }
        }
    }

    fclose(fp);
    lineNum++;
    return;
}

在统计字符数、行数、单词数的同时，对各个单词、词组出现的频率进行统计。

（3）单词频率统计

宏定义：

#define WORD_MAX_LENGTH   1024     //单词最长长度

#define isLetter(c)   (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z')))

#define isNumber(c)   ((c) >= '0' && (c) <= '9')

#define HASHMOD   22248619     //哈希表容量

单词结构体：

typedef struct wordNode 
{
    char word[WORD_MAX_LENGTH];
    char wordPreLow[WORD_MAX_LENGTH];//word excluding numbers in the end
    int time;
    struct wordNode *next;
}wordNode, *wordList;

全局变量：wordList headList[HASHMOD];

函数原型：int ELFhash(char* key)；//哈希函数

　　　　　void Mystrncpy_lwr(char* &s, char *t, int k)；//自定义的一个从字符串t拷贝指定长度字符串到字符串s，并转化为小写字母的函数

                  wordList CountFrequency(char word[], int lengthPre)；//传入单词字符及除去位于最后的数字的单词长度，返回单词结点（便于词组使用）

a）ELF哈希函数

int ELFhash(char* key) 
{
    //Hash function
    unsigned long h = 0, g;
    while (*key)
    {
        h = (h << 4) + *key++;
        g = h & 0xF0000000L;
        if (g)
            h ^= g >> 24;
        h &= ~g;
    }
    return(h % HASHMOD);
}

b）拷贝及小写转化

void Mystrncpy_lwr(char* &s, char *t, int k)
{
    //copy and change to lower case
    int i;
    for(i = 0; i < k; i++)
    {    
        s[i] = t[i];
        if (s[i] >= 'A' && s[i] <= 'Z')
            s[i] += 32;
    }
    s[i] = '\0';
}

c）单词频率统计

wordList CountFrequency(char word[], int lengthPre) 
{    
    //Count the frequency of words
    char* wordPreLow = new char[lengthPre + 1];
    int h;
    wordList wNode = NULL, p, q = NULL;

    Mystrncpy_lwr(wordPreLow, word, lengthPre);

    h = ELFhash(wordPreLow);

    if(headList[h] == NULL)
    {
        wNode = new wordNode;
        wNode->time = 1;
        strcpy(wNode->word, word);
        strcpy(wNode->wordPreLow, wordPreLow);
        wNode->next = NULL;
        headList[h] = wNode;
        headList[h]->next = NULL;
    }
    else
    {
        p = headList[h];
        while (p != NULL)
        {
            if (strcmp(p->wordPreLow, wordPreLow) == 0)
            {
                p->time++;
                if (strcmp(word, p->word) < 0)
                {
                    strcpy(p->word, word);
                }
                return p;
            }
            q = p;
            p = p->next;
        }
        if (p == NULL)
        {
            wNode = new wordNode;
            wNode->time = 1;
            strcpy(wNode->word, word);
            strcpy(wNode->wordPreLow, wordPreLow);
            wNode->next = NULL;
            q->next = wNode;
        }
    }
    return wNode;
}

（4）词组频率统计

词组结构体：

typedef struct phraseNode
{
    int time;
    struct phraseNode *next;
    wordList word1;
    wordList word2;
}phraseNode, *phraseList;

 存放两个单词的指针

全局变量：phraseList headList_Phrase[HASHMOD];

 函数原型：int ELFhash_Phrase(char* key1, char* key2)；//用于词组的哈希函数，使词组中两个单词对函数返回值都有用处

                  void CountFrequency_Phrase(wordList word1, wordList word2)；//传入词组中两个单词的指针

a）两个单词的哈希函数

int ELFhash_Phrase(char* key1, char* key2)
{    
    //Hash function for two words
    unsigned long h = 0, g;
    while (*key1)
    {
        h = (h << 4) + *key1++;
        g = h & 0xF0000000L;
        if (g)
            h ^= g >> 24;
        h &= ~g;
    }
    while (*key2)
    {
        h = (h << 4) + *key2++;
        g = h & 0xF0000000L;
        if (g)
            h ^= g >> 24;
        h &= ~g;
    }
    return(h % HASHMOD);
}

 b）词组频率统计

void CountFrequency_Phrase(wordList word1, wordList word2) 
{
    //Count the frequency of phrases

    if (word1 == NULL || word2 == NULL)
    {
        printf("Empty Pointer\n");
        return;
    }

    int h;
    phraseList pNode, p, q = NULL;
    h = ELFhash_Phrase(word1->wordPreLow, word2->wordPreLow);

    if (headList_Phrase[h] == NULL)
    {
        pNode = new phraseNode;
        pNode->time = 1;
        pNode->word1 = word1;
        pNode->word2 = word2;
        headList_Phrase[h] = pNode;
        headList_Phrase[h]->next = NULL;
    }
    else
    {
        p = headList_Phrase[h];
        while (p != NULL)
        {
            if (strcmp(p->word1->wordPreLow, word1->wordPreLow) == 0 && strcmp(p->word2->wordPreLow, word2->wordPreLow) == 0)
            {
                p->time++;
                break;
            }
            q = p;
            p = p->next;
        }
        if (p == NULL)
        {
            pNode = new phraseNode;
            pNode->time = 1;
            pNode->word1 = word1;
            pNode->word2 = word2;
            pNode->next = NULL;
            q->next = pNode;
        }
    }
}

（5）找出单词、词组中的前10个

全局变量：

wordNode wordTop10[11];

phraseNode phraseTop10[11]; 

函数原型：void Top10WordPhrase()；

a）排序找前十个

void Top10WordPhrase()
{
    int i, j;
    wordNode *p;
    phraseNode *q;

    for (i = 0; i < HASHMOD; i++)
    {
        //find top 10 words
        if (headList[i] != NULL)
        {
            p = headList[i];
            while (p != NULL)
            {
                for (j = 9; j >= 0 && p->time > wordTop10[j].time || ((p->time == wordTop10[j].time) && (strcmp(p->word, wordTop10[j].word) < 0)); j--)
                {
                    strcpy(wordTop10[j + 1].word, wordTop10[j].word);
                    wordTop10[j + 1].time = wordTop10[j].time;
                }
                if (j < 9)
                {
                    strcpy(wordTop10[j + 1].word, p->word);
                    wordTop10[j + 1].time = p->time;
                }
                p = p->next;
            }
        }
    }
    for (i = 0; i < HASHMOD; i++)
    {
        //find top 10 phrases

        if (headList_Phrase[i] != NULL)
        {
            q = headList_Phrase[i];
            while (q != NULL)
            {
                for (j = 9; j >= 0 && q->time > phraseTop10[j].time; j--)
                {
                    phraseTop10[j + 1].word1 = phraseTop10[j].word1;
                    phraseTop10[j + 1].word2 = phraseTop10[j].word2;
                    phraseTop10[j + 1].time = phraseTop10[j].time;
                }
                if (j < 9)
                {
                    phraseTop10[j + 1].word1 = q->word1;
                    phraseTop10[j + 1].word2 = q->word2;
                    phraseTop10[j + 1].time = q->time;
                }
                q = q->next;
            }
        }
    }
}

b）以文件形式输出

int i;
FILe *fout;

if ((fout = fopen("result.txt", "w")) == NULL) {
    printf("cannot open this file result.txt\n");
    exit(0);
}

fprintf(fout, "char_number : %d\n", characterNum);
fprintf(fout, "line_number : %d\n", lineNum);
fprintf(fout, "word_number : %d\n", wordNum);
fprintf(fout, "\n");

for (i = 0; i <= 9; i++)
{
    fprintf(fout, "%s: %d\n", wordTop10[i].word, wordTop10[i].time);
}
fprintf(fout, "\n");

for (i = 0; i <= 9; i++)
{
    fprintf(fout, "%s %s: %d\n", phraseTop10[i].word1->word, phraseTop10[i].word2->word, phraseTop10[i].time);
}

五、代码质量和性能分析

（1）质量分析

无错误或警告；

（2）性能分析

1）vs自带性能分析工具

                               （样本分析报告，运行时间15s左右）

                            （存储字符判断是否为单词的代码块）

                       （单词统计、词组统计函数的调用语句）

                                     （哈希表判断是否是空结点）

 分析：

a）通过对热行查看，运行次数最多的就是fgetc（）函数，但是因为整体架构的原因，不好修改，而且我觉得这个时间消耗也是必不可少的；

b）其他一些执行次数多的我感觉都是程序结构里比较重要的语句，然后暂时也没想到更好的方法；

c）之前担心的排序耗时多，结果发现排序函数只占不到1%，所以整个代码的执行时间还是在统计这一块；

d）对于string和字符数组两种形式，我只是在文件路径这里使用了string，修改成char型数组后发现二者时间相差不大；

c）因为我目前掌握的优化方法不多，只局限一些减少重复计算等，这些在具体编码时也考虑到了，比如多存一个单词的去掉后缀的小写形式减少重复计算等，程序运行时间也算比较快，所以优化的地方并不多。

2）Linux上性能分析

通过查找资料，可以用GPROF进行性能分析

                                             （函数调用情况）

                                                  （函数调用关系图）

分析：

a）由性能分析结果，可以看到，执行时间最长的就是单词和词语频率统计的函数，这跟样本数量太大有关； 词组统计的运行时间大致为单词统计的两倍，这也符合常理；

b）排第三的是排序函数，这个在我意料之外，因为之前vs性能分析结果中，排序的这个函数根本没有出现在性能报告的前面；

c）Linux上运行代码时，时间是windows上运行时间的几倍，初步猜测是Linux虚拟机的内存不够。

六、测试设计与分析

（1）助教的样例

运行时间： Release模式生成的.exe文件运行时间15s左右，但linux虚拟机上时间更慢，可能是内存等的原因。

输出结果： 字符数、行数、单词数均有偏差(╯﹏╰)b；

　　　　　 前十单词结果正确；

                   前十词组结果正确；

   

                         (左为我在windows上的输出，中为linux上的输出，右为样例输出）

（2）遍历文件夹

命令行参数：D:\调研报告（代码输出文件夹内所有文件名字）

输出：

按照深度优先搜索进行遍历；

（3）空文件夹

字符数、行数、单词数均为0；

（4）空文件

输出：

字符数、单词数为0，行数为1，因为空行也算一行；

（5）错误的文件路径

输出：

 输出错误信息

（6）只包含一个单词的文件（结束没有换行）

 文件内容：

输出：

（7）同一类单词按字典顺序输出

文件内容：

输出：

按单词的定义：ABcD、ABCd123、abcD344566666均算同一类单词，输出时按ASCII码最小（即ABCd123）输出；

（8）词组按词典顺序输出

文件内容：

输出：

词组中每个单词按他ASCII码最小的形式输出，由于123good555不算单词，所以它前后的gooD777、goOd也算词组，所以这一词组共出现了三次。

（9）不同类型文件

文件内容：

输出：

与助教的.exe文件一致

（10）特殊文件

文件内容：

用Notepad++打开为乱码；

输出：

                 （左为我的程序，右为助教的.exe文件）

可以看到，行数有区别，字符数有较大差别，可能还是在对文件处理、细节判断上有出入。

七、总结收获

       这次软工的个人作业整体的框架还不是很难，主要是细节很多，再加上个人编程经验实在不足，所以在构想编程方面花了大量时间，然后具体编程时效率也不高，而且犯了一些以前也经常犯的小错误，比如忘记“p = p->next;”、排序时数组下标搞错、某些情况没有及时用“break”跳出循环等等。

       此外，在代码调试上也花了大很多时间，然后调试的进展也不大。还有诸如代码移植、linux上代码分析等事项也耗费了很多时间，主要还是以前没有接触过的原因。总的来说，这周在这个作业上真的花了大量大量的时间，从周五晚开始，一直到周四，才算差不多完整地完成了作业，虽然仍然有很多瑕疵。

       收获的话还是有的，比如之前提到的一些小bug让我再次长了点记性，再就是学习了以前不会的遍历文件夹的方法，还有熟悉了像vs的使用、linux虚拟机的安装配置和在虚拟机上运行代码等等操作。通过这次作业，我把以前学的一些知识（如哈希表等）在实际中更灵活的运用，也一定程度是开阔了自己的思维。

附：

（1）Github管理代码

Github地址：https://github.com/hytu99/homework_1

 

（2）PSP表格

Status	Stages	预估耗时/min	实际耗时/min
Accept	【计划】 Planning	60	80
Accept	——估计时间 Estimate	60	80
Accept	【开发】 Development	790	1280
Accept	——需求分析 Analysis	10	5
Accept	——设计文档 Design Spec	40	40
Accept	——设计复审 Design Review	10	10
Accept	——代码规范 Coding Standard	10	5
Accept	——具体设计 Design	60	100
Accept	——具体编码 Coding	480	780
Accept	——代码复审 Code Review	60	40
Accept	——测试 Test	120	300
Accept	【记录用时】 Record Time Spent	20	10
Accept	【测试报告】 Test Report	60	40
Accept	【算工作量】 Size Measurement	20	15
Accept	【总结改进】 Postmortem	40	30
Accept	【合计】 Summary	990	1455