Apriori算法的C++实现

最新推荐文章于 2022-04-27 10:51:28 发布
最新推荐文章于 2022-04-27 10:51:28 发布
阅读量6.5k 收藏 40
点赞数 6
分类专栏： 数据挖掘
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scjthree/article/details/39963831
版权

Apriori是经典的购物篮分析算法。该算法用SQL实现难度较大，所以考虑用C++实现。花了两天，代码如下，原创转载请注明出处

//Apriori.c 
#include<iostream>
#include<set>
#include<map>
#include<string>
#include<vector>
using namespace std;
typedef map<set<string>,int> map_s;

map_s Ck ;//候选集Ck
map_s Lk ; //频繁项集Lk
vector<set<string> >  data; //原始数据
vector<set<string> >  L;    //频繁项集合
vector<string>        data2; //分割后的原始数据
int n,m;
int minSup = 2;
int minConf = 0.2;
set<string> s;
string in;
void Delete(map_s &Ck)
{
   for(  map_s::iterator l_it=Ck.begin();l_it!=Ck.end();l_it++ )
   {
      if( l_it->second< minSup)
      {
        Ck.erase(l_it);
      }
   }
}

int compset(set<string> s1,set<string> s2)
{
  int flag=0;
  //判断集合s1是不是s2的子集
  for( set<string>::iterator it=s1.begin(); it!=s1.end();it++ )
  {
     //s1有元素不在s2中
     if( s2.find(*it)==s2.end() )
     {
         flag=10;
         break;
     }
  }
  for( set<string>::iterator it=s2.begin(); it!=s2.end();it++ )
  {
     //s2有元素不在s1中
      if( s1.find(*it)==s1.end() )
      {
         flag+=1;               
         break;
      }
  }
  /*当flag==0,s1元素全部在s2中，s2元素也全部在s1中，s1==s2
    当flag==10,s1有元素不在s2中，s2所有元素都在s1中，s1包含了s2
    当flag==1,s1所有元素在s2中，s2有元素不在s1中，s2包含了s1
    当flag==11,s1 s2集合互不包含
  */
  return flag;
}

map_s apriori_gen(map_s &Ck,int k)
{
   //生成子集
   map_s Ck_temp;
   set<string> s_temp;
   for( map_s::iterator l_it1=Ck.begin();l_it1!=Ck.end();l_it1++ )
   {
      for( map_s::iterator l_it2=Ck.begin();l_it2!=Ck.end();l_it2++ )
      {
         //如果两个set一样，则说明是同一个KEY，跳过
         if(!((l_it1->first > l_it2->first)||(l_it1->first < l_it2->first)))
                   continue;
         //否则开始组装,遍历整个Ck
         for( set<string>::iterator s_it=l_it2->first.begin();s_it!=l_it2->first.end();s_it++ )
         {
               //如果该值在l_it1 set里面可以找到，不能组装
               if( l_it1->first.find(*s_it)!=l_it1->first.end())
                  continue;
               //否则进行组装,先把l_it1的set复制进去
               s_temp = l_it1->first;
               //再把l_it2的值放进去
               s_temp.insert(*s_it);
               //判断该组装的set是否已在生成集合中，如果之前已生成，则不需要往下运算
               if(Ck_temp.find(s_temp)!=Ck_temp.end())
                    continue;
               else  //否则放到生成的子集中
               {
                  Ck_temp.insert(pair<set<string>,int >(s_temp,0));
               }
         }
      }
   }
   
   //对于k=2的情况，需要扫描原始数据得出计数值
   if( 2 == k )
   {  
     for( map_s::iterator l_it=Ck_temp.begin();l_it!=Ck_temp.end();l_it++ ) 
      for(int i=0;i<data.size();i++)
       //l_it集合被data[i]完整包含，则计数值+1
       if( (10 == compset(data[i],l_it->first)) || (0 == compset(data[i],l_it->first))  )
                Ck_temp[l_it->first]++;
    
       //扫描完之后排除 非频繁项
     for( map_s::iterator l_it=Ck_temp.begin();l_it!=Ck_temp.end();l_it++ )
         if( Ck_temp[l_it->first] < minSup )
             Ck_temp.erase(l_it);
   }
   //如果是大于2的情况，扫描k-1的频繁项子集
   if( 2 < k )
   {
      //每次都循环获取每个Ck的k-1子集元素
      //如{I1,I2,I3}C3的子集是{I1,I2} {I2,I3} {I3,I4}
      //如果Ck的子集不在k-1的频繁项子集中，则去掉该Ck项
      for( map_s::iterator l_it=Ck_temp.begin();l_it!=Ck_temp.end();l_it++ )
      {
         int flag;
         for( set<string>::iterator s_it=l_it->first.begin();s_it!=l_it->first.end();s_it++ ) 
         {
           //开始求子集
           //首先把当前Ck项的集合保存
           s_temp=l_it->first;
           //去掉一个元素，即是它的k-1子集
           s_temp.erase(*s_it);
           //遍历频繁项集合L，看看是不是在频繁集中
           flag=1;
           for( int i=0;i<L.size();i++  )
           {
             //如果K-1子集在频繁项集中存在，则保留
             if( 0 == compset(s_temp,L[i]) )
             {
                  flag=0;
                  break;
             }
           }
           //如果找到了哪怕一个k-1子集项不在频繁项集中，直接退出
           if( flag ) break;
         }
         //只有所有的k-1子集在频繁项集中，才保留该Ck项
         if( flag ) Ck_temp.erase(l_it);
      }
   }

   cout<<"由L"<<k-1<<"产生的候选集C"<<k<<"   "<<"cout数(k=2以上不做计数)"<<endl;
   for( map_s::iterator l_it=Ck_temp.begin();l_it!=Ck_temp.end();l_it++ )
   {
        for( set<string>::iterator s_it=l_it->first.begin();s_it!=l_it->first.end();s_it++ )
             cout<<*s_it<<"  ";
        cout<<l_it->second<<endl;
   }
   return Ck_temp;
}

int main()
{ 
  cout<<"请输入事务，第一行输入事务数。每行第一个值输入该事务的item数"<<endl;
  //生成原始数据集
  cin>>n;
  for(int i=0;i<n;i++)
  { 
     s.clear();
     cin>>m;
     for(int j=0;j<m;j++)
     {
        cin>>in;
        s.insert(in);
        data2.push_back(in);
     }
     data.push_back(s); 
  }
  //扫描数据集D，生成C1
     //对于每个候选集里面的元素
     for( int j=0; j<data2.size();j++ )
     {
      int flag=1;
      //如果C1中存在该元素，计数值加1
      for( map_s::iterator l_it=Ck.begin();l_it!=Ck.end();l_it++ )
      {
        if( (l_it->first).find(data2[j]) != (l_it->first).end() )
        {
           Ck[l_it->first]++;
           flag=0;
           break;
        }
      }
     //不存在，插入到C1集合中
     if(flag)
     { 
          s.clear();
          s.insert(data2[j]);
          Ck.insert(pair<set<string>,int>(s,1));
     }
    }
    //去掉支持度不足的
    for(  map_s::iterator l_it=Ck.begin();l_it!=Ck.end();l_it++ )
    {
      if( l_it->second< minSup)
        Ck.erase(l_it);
    }



  cout<<"C1候选集:"<<endl;
  cout<<"项集"<<"     "<<"支持度计数"<<endl;
  
  for( map_s::iterator l_it=Ck.begin();l_it!=Ck.end();l_it++ )
  {
      for( set<string>::iterator s_it=(l_it->first).begin(); s_it!=(l_it->first).end(); s_it++)
         cout<<*s_it<<" "<<l_it->second<<endl;
  }
  
  int f_count=2;
  while( f_count )
  {
      //将Ck内的k-1频繁集全部保存到L集中
      for( map_s::iterator l_it=Ck.begin();l_it!=Ck.end();l_it++ )
        L.push_back(l_it->first);
      //获取Ck集，已清除掉小于支持度的候选集
      Ck=apriori_gen(Ck,f_count);     
      
      if( Ck.empty() )
      {
          break;
      }else{ f_count++; }
  }
 
  cout<<"最终的频繁集集合"<<endl;
  for( int i=0; i<L.size(); i++ )
  {
      for( set<string>::iterator s_it=L[i].begin(); s_it!=L[i].end(); s_it++)
         cout<<*s_it<<" ";
      cout<<endl;
  }

}


目前只实现到产生频繁集合，支持度默认计数2。在g++环境下编译 g++ -g Apriori.c -o apr  


测试数据如下：

4
3 I1 I2 I6
4 I1 I2 I3 I5
3 I2 I3 I7
5 I1 I3 I5 I6 I2 


输出如下：



用ORACLE格式化数据导出成文件，C++处理后返回文件给ORACLE，传到推荐数据库中即可完成这个算法的全流程。

当然目前还只是儿童玩具，因为所有的数据都是放在内存里的，数据量一大这个代码就不实用了。C++牛逼的地方在于可以直接调用linux底层的接口处理这一类问题，比如当内存不足时数据存到磁盘。我们这边内存有几十G，订单总量不超过1G，所以这个代码应该够用了，不够用时可以再扩展



亚存
关注
  • 6
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
频繁项集算法：Apriori算法的C++实现
hgqqtql的专栏
03-20 2548
Apriori算法是一种挖掘关联规则的频繁项集算法，其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集。 算法原理我一定不如 点击打开链接 说的明白，就只贴代码好了。 购物篮应该是放在数据库中，我把它写在文件D:/item.txt中。 有一点不同： ①代码中用了以下映射： totalID（项名-->整体编码的映射） freID（整体编码-->频繁项编码的映射）
Apriori 初步学习 + C++实现
Faulkner的博客
10-27 1434
1.基本概念 Apriori算法是一种挖掘关联规则的频繁项集算法，最早由R.Agrawal提出，现已广泛的运用到商业、网络安全等领域。最常见的淘宝相关推荐便包含有这一算法。 该算法的主要步骤为：(1) 找到所有支持度大于最小支持度的项目集，即频繁项集(Frequent Itemset)； (2) 使用第(1)步的频繁项目集产生期望的规则。 Apriori算法着重与第一步，挖掘频繁项集。
Apriori算法及C++实现
weixin_34120274的博客
08-23 363
最近工作比较忙，每天发在学习上的时间比较少，最近学的数据挖掘教程比较进度缓慢，上星期开始看的Apriori算法，这算是我接触的第一个数据挖掘方面的算法，看了2-3遍了解其原理。曾看过大侠说过，要想完全理解其算法的本质，即必须上机编写测试，哪怕是写出伪代码也要翻译成机器语言跑一遍，来感觉此算法的伟大。所以抽了个周六，详细编写了遍，并参考网上的例子，对其进行适当的优化。...
Apriori算法C++实现
11-11
用C++编程实现Apriori算法，用一种较为高效的解决方案
Apriori算法
10-23
用vc++6.0运行绝对没有问题。。可以观察到频繁项集以及关联规则。
Apriori:Apriori算法的C++实现
07-13
Apriori算法的C++实现 运行实现 将项目文件保存在一个文件夹中。 编译apriori.cpp 使用以下命令运行： （适用于 Linux/Mac） ./apriori > output.txt （适用于 Windows） apriori.exe > 输出.txt 关于输入数据...
数据挖掘 关联规则挖掘 Apriori算法 C++实现
m0_46516029的博客
04-27 1004
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、Apriori是什么，大致步骤？二、全部代码全部代码总结 前言 本文只是基于课程作业的相关理解，请谨慎参考，如有不妥，欢迎各位批评指正。 一、Apriori是什么，大致步骤？ 示例：Apriori算法是一种最有影响的布尔关联规则频繁项集的算法，Apriori 使用一乘坐逐层扫描的迭代方法，“K-1”项集用于搜索“K”项集。 大致步骤：首先找出频繁一项集的集合，该集合记为L1。L1用于找频繁2项集的集合L2,继续用L2找.
Apriori算法的c++实现 附测试数据
10-18
c++实现的Apriori算法，布尔关联规则挖掘频繁项集的算法，生成候选集与频繁项集，经过AllElectronics事物数据样本测试通过。 样本格式需要改动。附测试数据。
apriori算法（C++实现）
11-08
C++实现的apriori关联规则算法，在VC里运行
apriori算法c++程序实现，附测试数据以及使用说明
10-15
apriori 算法c++程序实现，附测试数据以及使用说明，codeblocks下运行通过。 绝对简单明了。
自己写的Apriori算法（c++实现）
11-06
数据挖掘中的经典关联规则算法，网上找了很多，不是不能运行，就是只能处理英文字母或数字，就花了几天时间自己写了个c++程序，用于处理字符串频繁项的挖掘。在c-free4.0和visual studio 2008上都能运行。
apriori算法的c语言实现
11-29
数据挖掘中经典apriori算法的c语言实现
Python学习教程之算法讲解：深入浅出Apriori关联分析算法
weixin_30858241的博客
08-15 136
在美国有这样一家奇怪的超市，它将啤酒与尿布这样两个奇怪的东西放在一起进行销售，并且最终让啤酒与尿布这两个看起来没有关联的东西的销量双双增加。这家超市的名字叫做沃尔玛。你会不会觉得有些不可思议？虽然事后证明这个案例确实有根据，美国的太太们常叮嘱她们的丈夫下班后为小孩买尿布，而丈夫们在买尿布后又随手带回了他们喜欢的啤酒。但这毕竟是事后分析，我们更应该关注的，是在这样的场景下，如何找出物品之间的关联规则...
apriori数据集_啤酒和尿布放在一起卖得更好？来看看这个故事背后的Apriori算法...
weixin_39720662的博客
11-18 475
点击上方蓝字，和我一起学技术。今天是机器学习专题的第19篇文章，我们来看经典的Apriori算法。Apriori算法号称是十大数据挖掘算法之一，在大数据时代威风无两，哪怕是没有听说过这个算法的人，对于那个著名的啤酒与尿布的故事也耳熟能详。但遗憾的是，随着时代的演进，大数据这个概念很快被机器学习、深度学习以及人工智能取代。即使是拉拢投资人的创业者也很少会讲到这个故事了，虽然时代的变迁令人唏...
C++实现apriori算法
random_repick的专栏
12-30 3424
#include "stdafx.h" #include #include #include #define T 2 //最小支持度 #define M 9 //样本数 #define N 5 //数据项数 using namespace std; //候选频繁项集：维数，频度，具体数据，获取频度 class freq_item{ public: int d
apriori算法c++实现
最新发布
03-29
不好意思，作为AI语言模型，我无法提供C语言的代码实现，但我可以提供算法的伪代码，供您参考： 输入：数据集D，最小支持度阈值minSup 输出：频繁项集 1. 创建大小为1的所有候选项集C1 2. 对于每个事务t∈D，对...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值