关联规则挖掘算法学习报告(2)

模式识别

#include using namespace std;

class Apriori {

private:

int Min_support;//最小支持度

vector vec_str;//保存从文件中读取的字符串 map map_str_int;//一项备选集 vector vec_item;//一项频繁集

vector vec_mutiItem_pre;//高项备选集 vector vec_mutiItem;//高项频繁集 public:

Apriori(void); ~Apriori(void);

//从文件中读取每一行字符串存入向量vec_str中

void ReadFile(ifstream &infile, const string &filename, &separator='\\\\');

//统计一项备选集支持度

void CountWord(const char &separator='\\\\'); //生成一项频繁集

void Generate_1ItemSets(); //生成二项频繁项备选集

void GenerateAlternative2(); //生成高项频繁项备选集

void GenerateAlternative(); //统计备选集支持度 void CountSupport(); //生成高项频繁集

void Generate_ItemSets(); //生成所有项频繁集

void Generate_AllItemSets(ostream &outfile); //输出一项频繁集到文件中

void Ouput1(ostream &outfile); //输出高项频繁集到文件中

void Ouput(ostream &outfile); };

#include \#include \

Apriori::Apriori(void) {

this->Min_support=5;//默认最小支持度

4

const char 模式识别

}

Apriori::~Apriori(void) { }

//从文件中读取每一行字符串存入向量vec_str中

void Apriori::ReadFile(std::ifstream &infile, const std::string &filename, const char &separator) {

infile.open(filename.c_str());//打开文件 if(!infile) {

cout<<\<

string word;

while(getline(infile,word))//每次从文件中读取一行字符串存入word中 this->vec_str.push_back(word);//在vec_str的末尾增加一个值为word的元素。

infile.close(); }

//统计一项备选集支持度

void Apriori::CountWord(const char &separator) {

string sentence,word;

for(vector::const_iterator

iter=this->vec_str.begin();iter!=this->vec_str.end();++iter) {

sentence=*iter;//取出一行字符串 //分隔词语

while(sentence.find(separator) != -1) {

word=sentence.substr(0, sentence.find(separator)); ++this->map_str_int[word];

sentence=sentence.substr(sentence.find(separator)+1, sentence.size()-1); }

++this->map_str_int[sentence]; } }

//生成一项频繁集

5

模式识别

void Apriori::Generate_1ItemSets() {

Item item;

for(map::const_iterator

iter=this->map_str_int.begin();iter!=this->map_str_int.end();++iter) {

//挑选支持度大于等于最小支持度的项 if(iter->second >= this->Min_support) {

item.key=iter->first; item.value=iter->second;

this->vec_item.push_back(item); } } }

//生成二项频繁项备选集

void Apriori::GenerateAlternative2() {

vector vecTemp;

for(vector::const_iterator

iter=this->vec_item.begin();iter!=this->vec_item.end()-1;++iter) {

vecTemp.push_back(iter->key); for(vector::const_iterator

iter2=iter+1;iter2!=this->vec_item.end();++iter2) {

vecTemp.push_back(iter2->key); mutiTemp.key=vecTemp; mutiTemp.value=0;

this->vec_mutiItem_pre.push_back(mutiTemp);//添加到二项频繁项备选集

vecTemp.pop_back(); }

vecTemp.clear(); } }

//生成高项频繁项备选集

void Apriori::GenerateAlternative() {

vector vecTemp;//低项频繁项元素 int count;

vector::const_iterator iterTemp;

6

模式识别

this->vec_mutiItem_pre.clear();//将备选集清空 for(vector::const_iterator

iter=this->vec_mutiItem.begin();iter!=this->vec_mutiItem.end()-1;++iter) {

vecTemp=iter->key;

for(vector::const_iterator

iter2=iter+1;iter2!=this->vec_mutiItem.end();++iter2) {

count=0;

for(vector::const_iterator

iter3=iter2->key.begin();iter3!=iter2->key.end();++iter3)

if(find(vecTemp.begin(),vecTemp.end(),*iter3)==vecTemp.end()) {

++count;

iterTemp=iter3; }

if(count!=1)//判断两个频繁项是否只有一个元素不相等 continue;

vecTemp.push_back(*iterTemp); mutiTemp.key=vecTemp; mutiTemp.value=0;

//判断备选集中是否已有此元素

if(count_if(this->vec_mutiItem_pre.begin(),this->vec_mutiItem_pre.end(),unaryPred)==0)

this->vec_mutiItem_pre.push_back(mutiTemp); vecTemp.pop_back(); }

vecTemp.clear(); } }

//统计备选集支持度

void Apriori::CountSupport() {

bool flag; //迭代行字符串

for(vector::const_iterator

iter=this->vec_str.begin();iter!=this->vec_str.end();++iter) {

//迭代备选集元素

for(vector::iterator

7

模式识别

iter2=this->vec_mutiItem_pre.begin();iter2!=this->vec_mutiItem_pre.end();++iter2) {

flag=true;

for(vector::const_iterator

iter3=iter2->key.begin();iter3!=iter2->key.end();++iter3) {

if(iter->find(*iter3)==-1) {

flag=false; break; } }

if(flag==true)

++iter2->value; } } }

//生成高项频繁集

void Apriori::Generate_ItemSets() {

this->vec_mutiItem.clear();

for(vector::const_iterator

iter=this->vec_mutiItem_pre.begin();iter!=this->vec_mutiItem_pre.end();++iter) {

if(iter->value >= this->Min_support) this->vec_mutiItem.push_back(*iter); } }

//生成所有项频繁集

void Apriori::Generate_AllItemSets(ostream &outfile) {

//生成一项频繁集 this->CountWord();

this->Generate_1ItemSets(); this->Ouput1(outfile);

//生成二项频繁项集

this->GenerateAlternative2(); this->CountSupport();

this->Generate_ItemSets();

8