C++回顾 统计词频问题 -- vector、map、hash_map（三种方式时间比较）

本博文我们通过三个程序比较统计词频问题的时间复杂度问题（末尾有用时及其分析）；

问题描述;

1）、找一篇文章，将所有单词输入至程序；（The Bible Holy为例）

2）、统计出每个单词的数量，即词频问题；

3）、增加停用词功能；（遇到此类词，直接略过）（网上搜）

4）、分别统计出读取文件并计算词频时间、排序所用时间；

5）、用 类 实现各函数（处统计时间的函数除外）。

 vector、map、hash_map 都要处理字符串的 去除标点符号、将大写字母转换成小写字母、不对数字进行统计 问题。因此，我们可以将处理这些函数进行封装。

StringUtil.h

#ifndef STRING_UTIL_H_
#define STRING_UTIL_H_

#include <string>

namespace stringutil
{
void erasePunct(std::string &s);
void stringToLower(std::string &s);
bool isAllDigit(const std::string &s);
}

#endif  /* STRING_UTIL_H_ */

StringUtil.cpp

#include "StringUtil.h"
#include <ctype.h>

using namespace std;

namespace stringutil
{

void erasePunct(string &s)
{
    string::iterator it = s.begin();
    while(it != s.end())
    {
        if(ispunct(*it))
            it = s.erase(it);
        else
            ++it;
    }
}
void stringToLower(string &s)
{
    for(string::iterator it = s.begin();
        it != s.end();
        ++it)
    {
        if(isupper(*it))
            *it = tolower(*it);
    }
}

bool isAllDigit(const std::string &s)
{
    for(string::const_iterator it = s.begin();
        it != s.end();
        ++it)
    {
        if(!isdigit(*it))
            return false;
    }

    return true;
}

}

 一、采用vector、pair；

采用的数据结构： 

1）、vector<string> stopList用于存放停用词；

2）、vector<pair<string, int> >  words  用于存放 除禁用词之外的其他The Bible Holy 的单词；

思路：

1）、用ReadStopFile函数 读取停用词到 stopList中；

2）、用ReadWordFile函数读取The Bible Holy到 words中；在我们读取的过程中首先要 去除标点符号、将word转化为小写、 跳过数字；

3）、然后判断该 单词 是否在 stoplist 中，若不在，最后添加单词 至 words中。

4）、对词频排序，这里我们采用algorithm库中的sort函数；

5）、对words vector进行遍历，打印之；

这里注意一点：除了在 main.cpp中显式调用的函数，我们将其他函数声明为 类 的私有函数。

函数声明如下：

#ifndef WORDFREQUENCY_H_
#define WORDFREQUENCY_H_

#include <vector>
#include <string>
#include <utility>

class WordFrequency
{
    public:
        WordFrequency(const std::string &filename, const std::string &stopFile);//初始化
        void ReadStopFile();
        void ReadWordFile();
        void sortWordByFrequency();
        void printWordFrequency()const;
    private:
        void addWordToDict(const std::string &word);
        bool isStopWord(const std::string &word)const;

        typedef std::vector<std::pair<std::string, int> >::iterator Wordit;//为了方便
        typedef std::vector<std::pair<std::string, int> >::const_iterator Wordkit;

        std::string filename_;
        std::string stopFile_;
        
        std::vector<std::string> stopList_;
        std::vector<std::pair<std::string, int> > words_;

};

#endif

函数实现如下：

//WordFrequency.cpp
#include "WordFrequency.h"
#include "StringUtil.h"
#include <algorithm>
#include <stdexcept>
#include <stdlib.h>
#include <fstream>

using namespace std;
using namespace stringutil;

WordFrequency::WordFrequency(const std::string &filename, const std::string &stopFile)
    :filename_(filename),stopFile_(stopFile)
{ }

void WordFrequency::ReadStopFile()
{
    ifstream in(stopFile_.c_str());
    if( !in )
        throw runtime_error("open file failure");
    string word;
    while(in >> word)
    {
        stopList_.push_back(word);
    }
    in.close();
}

void WordFrequency::ReadWordFile()
{
    ifstream infile(filename_.c_str());
    if( !infile )
        throw runtime_error("open file failure!");
    string word;
    while(infile >> word)
    {
        erasePunct(word);
        if( isAllDigit(word))
            continue;
        stringToLower(word);
        if( !isStopWord(word))
            addWordToDict(word);
    }
    infile.close();
}

bool WordFrequency::isStopWord(const string &word)const
{
    vector<string>::const_iterator it = stopList_.begin();
    while( it  != stopList_.end())
    {
        if( *it == word) 
            break;
        it ++;
    }
    return (it != stopList_.end());
}

void WordFrequency::addWordToDict(const string &word)
{
    Wordit it = words_.begin();
    while( it != words_.end())
    {
        if( it->first == word)
        {
            ++ it->second ;
            break;
        }
        it ++;
    }
    if(it == words_.end())
        words_.push_back(make_pair(word, 1)) ;
}

bool cmp(const pair<string, int> &a, const pair<string, int>&b)
{
    return a.second > b.second;
}

void WordFrequency::sortWordByFrequency()
{
    sort(words_.begin(), words_.end(), cmp);
}

void WordFrequency::printWordFrequency()const
{
    Wordkit it = words_.begin();
    while(it != words_.end())
    {
        printf("words: %s, frequency: %d
",it->first.c_str(),it->second);
        it ++;
    }
}

main.cpp

//main.cpp
#ifndef _STDC_FORMAT_MACROS
#define _STDC_FORMAT_MACROS
#endif /* _STDC_FORMAT_MACROS */
#include <inttypes.h>

#include "WordFrequency.h"
#include <iostream>
#include <vector>
#include <stdexcept>
#include <sys/time.h>
#include <stdio.h>
#include <string.h>
using namespace std;

int64_t gettime();

int main(int argc, const char *argv[])
{
    if(argc < 3)
        throw runtime_error("exe,filename, stopfile");
    int64_t starttime =gettime();
    WordFrequency wf(argv[1], argv[2]);
    wf.ReadStopFile();
    wf.ReadWordFile();
    
    int64_t readtime = gettime();
    wf.sortWordByFrequency();

    int64_t sorttime = gettime();

    printf("readfile time: %lld ms
",(readtime-starttime)/1000); 
    printf("sortfile time: %lld ms
",(sorttime-readtime)/1000);  
    
    wf.printWordFrequency();
    return 0;
}

int64_t gettime()
{
    struct timeval tv;
    ::memset(&tv, 0, sizeof tv);
    if(::gettimeofday(&tv, NULL) == -1)
    {
        throw runtime_error("gettimeofday");
    }
    int64_t t = tv.tv_usec;
    t += tv.tv_sec * 1000 * 1000;
    return t;
}

二、map、set；

相较于第一种，这种方式用到的数据结构有  

1、std::set<std::string> StopList_ 用于存放停用词；
2、std::map<std::string, int> words_ 用于存放The Bible Holy 中除了停用词之外的词；

3、std::vector< std::pair<std::string,int> > copyWords_ 由于map不具备排序功能，故需要将其转存均vector中。

WordFrequency.h

#ifndef WORDFREQUENCY_H_
#define WORDFREQUENCY_H_

#include <vector>
#include <map>
#include <set>
#include <string>
class WordFrequency
{
    public:
        WordFrequency(const std::string &filename, const std::string &stopfile);
        void ReadStopFile();
        void ReadWordFile();

        void copyWordToVector();
        void sortWordByFrequency();
        void printFrequency()const;
        
    private:
        std::string filename_;
        std::string stopfile_;

        std::set<std::string> StopList_;
        std::map<std::string, int> words_;
            
        std::vector< std::pair<std::string,int> > copyWords_;
};

#endif

WordFrequency.cpp

//WordFrequency.cpp
#include "WordFrequency.h"
#include "StringUtil.h"
#include <fstream>
#include <algorithm>
#include <stdio.h>
#include <stdexcept>
using namespace std;
using namespace stringutil;

WordFrequency::WordFrequency(const string &filename, const string &stopfile)
    :filename_(filename),stopfile_(stopfile)
{ }

void WordFrequency::ReadStopFile()
{
    ifstream infile(stopfile_.c_str());
    if( !infile )
        throw runtime_error("open file failure");
    string word;
    while(infile >> word)
        StopList_.insert(word);

    infile.close();
}

void WordFrequency::ReadWordFile()
{
    ifstream infile(filename_.c_str());
    if( !infile )
        throw runtime_error("open file failure");
    words_.clear();
    string word;
    while(infile >> word) //读取单词
    {
        erasePunct(word); //去除标点
        stringToLower(word);//转为小写
        if(isAllDigit(word))//去除数字
            continue;
        if( StopList_.count(word) == 0) //set中 count 标识 word这个单词是否存在
            words_[word]++; //如果存在，int++， 如果不存在，增添至 map中 
            //words_[word]= cnt（词频数）
    }
    
    infile.close();
}

void WordFrequency::copyWordToVector()
{
    copyWords_.clear();
    //back_inserter(copyWords_)
    //front_inserter
    copy(words_.begin(),words_.end(),back_inserter(copyWords_));
}

bool cmp(const pair<string, int> &a, const pair<string, int> &b)
{
    return a.second > b.second;
}
    
void WordFrequency::sortWordByFrequency()
{
    sort(copyWords_.begin(), copyWords_.end(),cmp); //排序
}

void WordFrequency::printFrequency() const
{
    for(vector<pair<string, int> >::const_iterator it = copyWords_.begin(); 
         it != copyWords_.end(); 
         ++it)
    {
        printf("word :%s, frequency: %d
", it->first.c_str(), it->second); //打印
    }
}

main.cpp：

比上一程序的main函数多了一行

//多出的一行copyWordToVector
int64_t readtime = gettime();
wf.copyWordToVector();
wf.sortWordByFrequency();

三、哈希表（c11特性）：

程序三与程序二非常相似，只是其头文件WordFrequency.h不同，因此我们只给出 .h文件；

注意编译时 ，g++  *.cpp -std=c++0x

WordFrequency.h

//WordFrequency.h
#ifndef WORDFREQUENCY_H_
#define WORDFREQUENCY_H_

#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <string>
class WordFrequency
{
    public:
        WordFrequency(const std::string &filename, const std::string &stopfile);
        void ReadStopFile();
        void ReadWordFile();

        void copyWordToVector();
        void sortWordByFrequency();
        void printFrequency()const;
        
    private:
        std::string filename_;
        std::string stopfile_;

        std::unordered_set<std::string> StopList_;
        std::unordered_map<std::string, int> words_;
            
        std::vector< std::pair<std::string,int> > copyWords_;
};

#endif

以上三个程序（所采用的数据结构不同）性能比较：

程序一：读取文件时间：42997ms、排序时间 7ms；

程序二：读取文件时间：1294ms、排序时间 10ms；

程序三：读取文件时间： 616ms、排序时间 9ms；

分析：

读取时间：

程序一采用的是vector，所以每一次 从 txt 读取一个单词 都要先遍历一遍停用词的vector，然后再顺序遍历 一次 vector，以查找该单词是否已经存在，故其平均查找时间复杂度为 O（N*N）；

程序二采用的是 map与set。map的实现 是根据 平衡二叉树（具体是红黑树），其查找平均速度是n*lgN； 而且 如果不存在时，自动添加该元素至map中，词频置为1。

程序三采用的是哈希表， unordered_map，与unordered_set ，其查找时间复杂度为 常量O(1)；

排序时间：

程序一所用时间比程序二、三多了几毫秒，这是因为map不具备排序功能，因为要转存至vector中。而多出来的这几毫秒就是转存时间。