下载文档原格式
apriori算法实验报告Apriori 算法实验报告一、实验背景随着信息技术的快速发展，数据量呈现爆炸式增长。
如何从海量数据中挖掘出有价值的信息成为了一个重要的研究课题。
关联规则挖掘作为数据挖掘中的一个重要分支，能够发现数据中项集之间的关联关系。
Apriori 算法是关联规则挖掘中最经典、最具影响力的算法之一，它在商业、医疗、金融等领域有着广泛的应用。
二、实验目的本次实验的主要目的是深入理解和掌握 Apriori 算法的原理和实现过程，并通过实际数据进行实验，验证算法的有效性和性能，同时分析算法的优缺点，为实际应用提供参考。
三、实验原理Apriori 算法基于频繁项集的先验知识，通过逐层搜索的方式找出数据集中的频繁项集，进而生成关联规则。
其核心思想包括两个方面：一是如果一个项集是频繁的，那么它的所有子集也一定是频繁的；二是如果一个项集是非频繁的，那么它的所有超集也一定是非频繁的。
算法的实现过程主要包括以下步骤：1、首先，扫描数据集，统计每个项的出现次数，得到候选 1 项集的支持度。
根据设定的最小支持度阈值，筛选出频繁 1 项集。
2、然后，基于频繁 1 项集，通过自连接生成候选 2 项集，再次扫描数据集计算候选 2 项集的支持度，筛选出频繁 2 项集。
3、依此类推，不断通过自连接和剪枝操作生成更高阶的候选项集，并计算其支持度，筛选出频繁项集，直到没有新的频繁项集产生为止。
四、实验环境本次实验使用的编程语言为 Python，主要使用了`pandas`和`mlxtend`库来进行数据处理和算法实现。
开发环境：Jupyter Notebook操作系统：Windows 10五、实验数据实验数据采用了一个超市购物数据集，其中包含了顾客的购物记录，每条记录表示一位顾客购买的商品列表。
六、实验步骤1、数据预处理读取数据文件，将数据转换为适合算法处理的格式。
对数据进行清洗和整理，去除噪声和异常值。
2、算法实现定义计算支持度和置信度的函数。
apriori算法最大频繁项集[Apriori算法最大频繁项集]Apriori算法是一种用于数据挖掘的常用算法，用于发现数据集中的频繁项集。
频繁项集是指经常同时出现在一个数据集中的一组项。
Apriori算法通过生成候选项集并使用支持度来筛选出频繁项集。
在本文中，我们将一步一步回答有关Apriori算法中最大频繁项集的问题。
第一步：理解频繁项集频繁项集是指经常同时出现在一个数据集中的一组项。
例如，在一个购物篮数据集中，频繁项集可以是一组同时出现在许多购物篮中的商品。
发现频繁项集可以帮助我们了解数据集中的潜在关联规则。
第二步：了解Apriori算法Apriori算法是一种用于发现频繁项集的经典算法。
该算法基于一个重要的性质，即如果一个项集是频繁的，那么它的所有子集也是频繁的。
Apriori算法通过迭代地产生候选项集并使用支持度来筛选出频繁项集。
第三步：生成候选项集Apriori算法首先生成长度为1的候选项集，即单个项。
然后，它根据频繁项集的支持度阈值筛选出频繁项集。
接下来，Apriori算法基于频繁项集生成长度为2的候选项集。
这个过程继续进行，直到无法生成更长的候选项集为止。
第四步：计算支持度支持度是指一个项集在数据集中出现的频率。
在Apriori算法中，支持度用来衡量一个项集的重要性。
Apriori算法计算每个候选项集的支持度，并用支持度阈值来筛选出频繁项集。
支持度阈值是指一个项集必须满足的最低支持度要求。
第五步：筛选出频繁项集Apriori算法根据支持度阈值筛选出频繁项集。
频繁项集是指满足最低支持度要求的项集。
这些频繁项集是数据集中经常出现的项集，它们可以帮助我们了解数据集中的关联规则。
第六步：找出最大频繁项集最大频繁项集是指不再包含其他频繁项集的项集。
在Apriori算法中，最大频繁项集可以由频繁项集合并来得出。
如果一个频繁项集的所有子集都不是频繁的，那么它就是最大频繁项集。
最后总结：Apriori算法是一种经典的发现频繁项集的算法。
发现频繁项集的⽅法Apriori算法我们是通过算法来找到数据之间的关联规则（两个物品之间可能存在很强的相关关系）和频繁项集（经常出现在⼀起的物品的集合）。
我们是通过⽀持度和置信度来定义关联规则和频繁项集的⼀个项集⽀持度是指在所有数据集中出现这个项集的概率，项集可能只包含⼀个选项，也有可能是多个选项的组合。
置信度针对于啤酒——>尿布这样的关联规则来定义，计算⽅式为⽀持度（啤酒，尿布）/⽀持度啤酒，其中⽀持度（啤酒、尿布）为3/5，⽀持度啤酒为4/5，所以他的置信度为3/4，即置信度为75%，这意味着在啤酒的规则中，有0.75的规则都适⽤。
但是在这样的规则中，如果需要求出所有规则，那么计算量⽐较⼤，这就可以⽤到 Apriori算法Apriori 的原理：如果某个项集是频繁项集，那么它所有的⾮空⼦集也是频繁的（先验原理）。
即如果 {0,1} 是频繁的，那么 {0}, {1} 也⼀定是频繁的。
反过来能发现如果⼀个项集是⾮频繁的，那么它的所有超集也是⾮频繁的。
这样就不⽤计算他的⽀持度了，可以减少计算量。
计算步骤为： 先会⽣成所有单个物品的项集列表，扫描交易记录来查看哪些项集满⾜最⼩⽀持度要求（⼀般会给⼀个最⼩⽀持度），那些不满⾜最⼩⽀持度的集合会被去掉，对剩下的集合进⾏组合以⽣成包含两个元素的项集，接下来重新扫描交易记录，去掉不满⾜最⼩⽀持度的项集，重复进⾏直到所有项集都被去掉。
提⾼Apriori算法的效率1、基于散列的技术当扫描数据库中的每个事务时，由C1中的候选频繁项集1项集产⽣频繁项集1项集L1时，可以对每个事务产⽣所有的2项集，将他们散列（映射）到散列表中的不同桶中，并增加对应的桶计数。
在散列表中，对应桶计数低于⽀持度阈值的2项集不可能是频繁的，可以删除掉。
2、事物压缩不包含任何频繁项集的K项集的事务不可能包含任何频繁（K+1）项集。
这种事务在之后的考虑时，可以被标记或者删除，因为产⽣的j项集（j>K）的数据库扫描不再需要他们。
数据挖掘apriori算法的应用实例什么是数据挖掘apriori算法、为什么要使用apriori算法、apriori算法的基本原理是什么、apriori算法的应用实例有哪些等问题。
标题：数据挖掘apriori算法的应用实例引言：数据挖掘是一门重要的计算机科学领域，旨在从大规模数据集中发现隐藏的模式和知识。
而apriori算法是数据挖掘中一种经典且常用的关联规则挖掘算法，主要用于分析事务数据中的频繁项目集并发现它们之间的关联关系。
本文将以apriori算法为主题，依次深入介绍apriori算法的基本原理和应用实例，并分析其在不同领域中的具体应用与效果。
第一部分：数据挖掘apriori算法的基础知识1.1 数据挖掘概述和背景1.2 关联规则挖掘的概念及其应用第二部分：为什么要使用apriori算法2.1 关联规则挖掘的必要性2.2 apriori算法的优势和适用性第三部分：apriori算法的基本原理3.1 频繁项集和支持度的定义3.2 apriori原理及其核心概念3.3 Apriori算法的流程和实现步骤第四部分：apriori算法的应用实例4.1 市场篮子分析4.1.1 超市购物篮分析4.1.2 在线购物行为分析4.1.3 商品推荐系统4.2 网络安全领域4.2.1 入侵检测系统4.2.2 虚拟网络环境4.3 医疗领域4.3.1 疾病诊断和预测4.3.2 药物推荐和副作用预测第五部分：总结与展望5.1 apriori算法的优势与局限性5.2 apriori算法未来发展趋势5.3 结论在第一部分中，我们将对数据挖掘和关联规则挖掘进行简要介绍，以奠定读者对本文主题的了解基础。
在第二部分中，我们将分析为什么选择使用apriori算法，包括关联规则挖掘的重要性和apriori算法的优点。
第三部分将重点介绍apriori算法的基本原理，从频繁项集和支持度的定义开始，逐步引入apriori原理和核心概念，并详细描述Apriori算法的流程和实现步骤。
apriori算法最大频繁项集介绍在数据挖掘领域，频繁项集是指在一个数据集中经常同时出现的项的集合。
频繁项集挖掘是一种常见的数据挖掘任务，可以用于发现数据中的关联规则。
apriori算法是一种用于发现频繁项集的经典算法，它通过利用数据中的Apriori原理，逐步生成候选项集，并使用支持度来筛选出频繁项集。
Apriori原理Apriori原理是指如果一个项集是频繁的，那么它的所有子集也是频繁的。
换句话说，如果一个项集不频繁，那么它的所有超集也不可能是频繁的。
Apriori算法基于这个原理，通过逐步生成候选项集来减少搜索空间，从而提高算法效率。
Apriori算法步骤Apriori算法的主要步骤如下：1.初始化：将每个单项作为候选项集，并计算其支持度。
2.生成候选项集：根据上一轮的频繁项集，生成下一轮的候选项集。
具体而言，对于k-1项的频繁项集，将其两两组合生成k项的候选项集。
3.剪枝：对于生成的候选项集，通过Apriori原理剪去不频繁的项集。
4.计算支持度：对剪枝后的候选项集，扫描数据集，计算每个候选项集的支持度。
5.筛选频繁项集：根据设定的最小支持度阈值，筛选出频繁项集。
6.生成关联规则：根据频繁项集，生成关联规则，并计算其置信度。
7.根据设定的最小置信度阈值，筛选出满足要求的关联规则。
生成候选项集在Apriori算法中，生成候选项集是一个重要的步骤。
候选项集的生成是通过对频繁项集的连接操作实现的。
具体而言，对于k-1项的频繁项集，将其两两组合生成k项的候选项集。
例如，对于频繁项集{A, B}和{B, C}，可以生成候选项集{A, B, C}。
剪枝剪枝是为了减少搜索空间，提高算法效率。
在Apriori算法中，剪枝操作是通过Apriori原理实现的。
具体而言，如果一个候选项集的某个子集不是频繁项集，那么该候选项集也不可能是频繁项集。
因此，在计算候选项集的支持度之前，需要对候选项集进行剪枝操作。
计算支持度在Apriori算法中，支持度是衡量项集在数据集中出现的频率的度量。
查看,运用apriori算法,找到频繁项集,并分析频繁项集产生的关联规则是否是有效关联
规则
Apriori算法的原理是：在一个数据库中寻找频繁项集。
Apriori算法的基本思想是：如果某个项集是频繁的，那么它的所有子集也是频繁的。
它使用“贪心”的方法来发现频繁项集，它维护了频繁项集的一个层次结构，例如一个项集是频繁的，它的所有子集都是频繁的。
其基本步骤包括：
1. 计算每个单项的支持度，从而找出支持度大于给定阈值的项集。
2. 从单项项集中构造候选集，过滤掉不满足最小支持度要求的候选集。
3. 根据剩余的候选集计算支持度，筛选出满足最小支持度要求的频繁项集。
4. 基于频繁项集构造关联规则，并评估规则的有效性。
根据上述步骤，我们可以得出频繁项集并分析频繁项集产生的关联规则是否是有效关联规则。
我们可以使用可信度和支持度来衡量关联规则的有效性。
可信度表示规则
X-Y的置信度，即当X发生时，Y也可能发生的概率；而支持度表示X-Y的支持度，即X和Y同时发生的概率。
如果可信度和支持度都满足阈值，则说明这个规则是有效的关联规则。
一、前言Weka是一款流行的数据挖掘工具，其内置了多种经典的数据挖掘算法。
其中，Apriori算法是一种用于发现数据集中频繁项集的经典算法。
在本次实验中，我们将对Weka中的Apriori算法进行实验，并总结经验体会。
二、实验准备1. 数据集准备：选择一个符合Apriori算法输入要求的数据集，本次实验选取了一个包含购物篮信息的数据集，用于分析不同商品之间的关联规则。
2. Weka环境准备：确保Weka软件已经安装并能够正常运行。
三、实验步骤1. 数据集加载：我们将选取的数据集导入Weka软件中，确保数据集能够正确显示。
2. 参数设置：在Weka中，Apriori算法有一些参数需要设置，如最小支持度、最小置信度等。
根据实际需求，设置适当的参数。
3. 算法执行：执行Apriori算法，观察结果。
可以得到频繁项集、关联规则等信息。
4. 结果分析：根据算法输出的结果，分析不同项集之间的关联规则，并进行对比和总结。
四、实验结果1. 频繁项集分析：通过Apriori算法的执行，得到了数据集中的频繁项集信息。
可以发现一些商品之间的频繁组合，为进一步的关联规则分析提供了基础。
2. 关联规则分析：根据频繁项集，进一步推导出了一些关联规则。
如果购买了商品A，那么购买商品B的概率较大。
这对于商家进行商品搭配和促销活动有一定的指导作用。
3. 算法性能评估：除了得到具体的关联规则外，还可以对算法的性能进行评估。
包括算法执行时间、内存占用、参数敏感性等方面的评估。
五、实验体会1. 算法优缺点：经过实验，我们发现Apriori算法在处理大规模数据集时存在一定的计算复杂度，需要进行优化才能适应大规模数据挖掘的需求。
但在小规模数据集上，其表现仍然较为理想。
2. 参数选择经验：在实验中，我们也总结出了一些参数选择的经验，如支持度和置信度的合理选择范围，以及对于不同数据集的适应性。
3. 应用前景展望：关联规则挖掘在电商、市场营销等领域有着广泛的应用前景，我们相信在未来的实际工作中，能够将所学到的知识应用到真实的业务场景中。
关联规则挖掘实验报告一、实验介绍关联规则挖掘是数据挖掘中的一种重要技术，用于发现数据集中的频繁项集和关联规则。
本次实验旨在通过使用Apriori算法和FP-Growth算法来挖掘一个超市销售数据集中的频繁项集和关联规则。
二、实验步骤1. 数据准备本次实验使用的数据集为一个超市销售数据，包括了超市中各个商品的销售记录。
首先需要将数据导入到Python环境中，并进行预处理，例如去除重复项、缺失值等。
2. Apriori算法挖掘频繁项集和关联规则Apriori算法是一种常用的关联规则挖掘算法，其基本思想是利用先验知识来减少搜索空间。
我们可以通过设置最小支持度和最小置信度来筛选出频繁项集和关联规则。
在本次实验中，我们首先使用Apriori算法来挖掘频繁项集和关联规则。
具体步骤如下：（1）设置最小支持度和最小置信度；（2）利用Apriori算法生成候选项集；（3）根据候选项集计算支持度，并筛选出满足最小支持度的频繁项集；（4）根据频繁项集生成候选规则；（5）根据候选规则计算置信度，并筛选出满足最小置信度的关联规则。
3. FP-Growth算法挖掘频繁项集和关联规则FP-Growth算法是一种基于频繁模式树的关联规则挖掘算法，相比于Apriori算法具有更高的效率。
在本次实验中，我们也使用FP-Growth算法来挖掘频繁项集和关联规则。
具体步骤如下：（1）设置最小支持度和最小置信度；（2）利用FP-Growth算法生成频繁模式树；（3）从频繁模式树中提取满足最小支持度的频繁项集；（4）根据频繁项集生成候选规则；（5）根据候选规则计算置信度，并筛选出满足最小置信度的关联规则。
三、实验结果分析1. Apriori算法结果分析在本次实验中，我们设置了最小支持度为0.05，最小置信度为0.5。
通过使用Apriori算法，我们得到了如下结果：（1）频繁项集：共有22个频繁项集，其中最大的频繁项集包含了5个商品。
（2）关联规则：共有87条关联规则，其中置信度最高的规则为{薯片} -> {可乐}，置信度为0.8。
Apriori算法实验报告1实验目的学会用Apriori算法对数据进行频繁项集和关联规则的挖掘，同时适当的改进Apriori算法2 实验环境程序语言：Java 实验数据：数据堂下载的模拟数据8万多条3 算法描述1 .Apriori介绍Apriori算法使用频繁项集的先验知识，使用一种称作逐层搜索的迭代方法，k项集用于探索(k+1)项集。
首先，通过扫描事务（交易）记录，找出所有的频繁1项集，该集合记做L1，然后利用L1找频繁2项集的集合L2，L2找L3，如此下去，直到不能再找到任何频繁k项集。
最后再在所有的频繁集中找出强规则，即产生用户感兴趣的关联规则。
其中，Apriori算法具有这样一条性质：任一频繁项集的所有非空子集也必须是频繁的。
因为假如P(I)< 最小支持度阈值，当有元素A添加到I中时，结果项集（A∩I）不可能比I出现次数更多。
因此A∩I也不是频繁的。
2 连接步和剪枝步在上述的关联规则挖掘过程的两个步骤中，第一步往往是总体性能的瓶颈。
Apriori算法采用连接步和剪枝步两种方式来找出所有的频繁项集。
1）连接步为找出Lk（所有的频繁k项集的集合），通过将Lk-1（所有的频繁k-1项集的集合）与自身连接产生候选k项集的集合。
候选集合记作Ck。
设l1和l2是Lk-1中的成员。
记li[j]表示li中的第j项。
假设Apriori算法对事务或项集中的项按字典次序排序，即对于（k-1）项集li，li*1+<li*2+<……….<li*k-1]。
将Lk-1与自身连接，如果(l1[1]=l2[1])&&( l1[2]=l2*2+)&&……..&& (l1[k-2]=l2[k-2])&&(l1[k-1]<l2[k-1])，那认为l1和l2是可连接。
连接l1和l2 产生的结果是,l1*1+,l1*2+,……,l1*k-1],l2[k-1]}。
apriori算法实例Apriori算法是数据挖掘领域中的一种经典算法，它用于频繁项集的挖掘。
该算法的核心思想是利用频繁项集的性质，通过逐层扫描事务数据库来产生候选项集和频繁项集。
我们来看一个简单的实例，假设我们有一个超市的销售数据，里面存储了顾客购买的商品信息，如下表所示：| 顾客ID | 购买的商品 ||--------|------------|| 1 | A, B, C || 2 | A, C, D || 3 | B, E || 4 | A, C, E |我们要利用Apriori算法来挖掘这个数据集中的频繁项集。
首先，我们需要设定一个最小支持度的阈值，以确定哪些项集是频繁的。
假设我们设置阈值为2，即一个项集在数据集中出现的次数必须不少于2次，才被认为是频繁的。
第一步，我们需要扫描整个数据集，统计每个项集出现的次数，并得到所有的频繁1项集。
在上面的数据集中，所有的1项集为{A}、{B}、{C}、{D}和{E}，其中{A}、{B}和{C}的出现次数都不少于2次，因此它们是频繁的。
第二步，基于频繁1项集，我们可以产生所有的候选2项集。
具体来说，我们需要找到所有的大小为2的子集，来组成新的2项集。
在上面的数据集中，所有的候选2项集为{A,B}、{A,C}、{A,D}、{A,E}、{B,C}、{B,E}和{C,E}。
然后，我们需要扫描整个数据集，统计每个候选2项集出现的次数，并得到所有的频繁2项集。
在上面的数据集中，所有的频繁2项集为{A,C}和{C,E}。
第三步，基于频繁2项集，我们可以产生所有的候选3项集。
具体来说，我们需要找到所有的大小为3的子集，来组成新的3项集。
在上面的数据集中，所有的候选3项集为{A,C,E}。
然后，我们需要扫描整个数据集，统计每个候选3项集出现的次数，并得到所有的频繁3项集。
在上面的数据集中，所有的频繁3项集为{A,C,E}。
最终，我们得到了该数据集中的所有频繁项集，它们分别为{A}、{B}、{C}、{E}、{A,C}、{C,E}和{A,C,E}。
实验三、应用 Apriori 算法挖掘频繁项集学院计算机科学与软件学院•实验目的：（1）熟悉 VC++编程工具和 Apriori 频繁项集挖掘算法。
（2）根据管理层的需求，确定数据挖掘的任务，明确数据挖掘的功能，也就是明确要挖掘什么。
（3）由确定的数据挖掘任务，从实验一处理后的结果中，采用切块或切片等联机分析处理技术，选择出挖掘任务相关数据。
（4）用 VC++编程工具编写 Apriori 算法的程序，对任务相关数据运行 Apriori算法，挖掘出所有的频繁项集。
1.写出实验报告。
•实验原理：1 、Apriori 算法Apriori 使用一种称作逐层搜索的迭代方法，k 项集用于探索（k+1）项集。
首先，通过扫描数据库，累计每个项的计数，并收集满足最小支持度的项，找出频繁 1 项集的集合。
该集合记作 L 1 。
然后，L 1 用于找频繁 2 项集的集合L 2 ，L 2 用于找 L 3 ，如此下去，直到不能再找到频繁 k 项集。
找每个 L k 需要一次数据库全扫描。
2、提高频繁项集逐层产生的效率Apriori 性质：频繁项集的所有非空子集也必须是频繁的。
三、实验内容：1、实验内容在给定的数据中提取统一购物篮购买的商品信息，由这些数据构成事务数据库 D，挖掘其中的频繁项集 L。
挖掘频繁项集的算法描述如下：Apriori 算法：使用逐层迭代找出频繁项集输入：事务数据库 D；最小支持度阈值。
输出：D 中的频繁项集 L。
（1） L 1 = find_frequent_1-itemsets(D); // 挖掘频繁 1-项集，比较容易（2） for (k=2;L k-1 ≠Φ ;k++) {（3） C k = apriori_gen(L k-1 ,min_sup); // 调用 apriori_gen 方法生成候选频繁k-项集分为两步：合并、减枝（4） for each transaction t ∈ D { // 扫描事务数据库 D（5） Ct = subset(C k ,t);（6） for each candidate c ∈ Ct（7） c.count++; // 统计候选频繁 k-项集的计数（8） }（9） L k ={c ∈ Ck|c.count≥min_sup} // 满足最小支持度的 k-项集即为频繁 k-项集（10） }（11） return L= ∪ k L k ; // 合并频繁 k-项集（k>0）算法在根据频繁 k-1 项集生成频繁 K 项集过程中要计算频繁 K 项集中每个元素的支持度，并计算 K 项集中每个 k-1 项子集是否在 F k-1 中，上述两条任何一条不满足，则删去这个 K 项集中的元素。
2 、实验过程1、打开试验用数据，读取出同一流水号的商品 ID 并取前 5 位，生成以行为单位生成事务数据集 transitions;2、ind_frequent_1-itemsets 生成频繁一项集for（each transaction in transitions）{for(each item in transaction）{oneItemSet；oneItemSet.count++；//对 1 项集进行计数}}3、apriori-gen (L k-1 ) 候选集产生算法For all itemset p∈Lk-1 doFor all itemset q∈Lk-1 doIf p.item1=q.item1, p.item2=q.item2, …,p.itemk-2=q.itemk-2,p.item k-1 !=q.item k-1thenbegin c=p∞q//p、q 合并后任意的 L k-1 子集if has_infrequent_subset(c, L k-1 )then delete c //存在 c 不属于 L k-1 剪枝else add c to CkEndReturn Ck4、has_infrequent_subset(c, L k-1 ）判断候选集的元素For all (k-1)-subsets of c doIf Not(S∈Lk-1) THEN return TRUE;Return FALSE;1.流程图4、主要程序代码1、//产生事务数据库代码（加注释）#include<iostream>#include<string>#include<fstream>#include<algorithm>using namespace std;class Sales_n{public:string serial;int market;char date[10];int sn;int id;float num;float price;};int main(){//////////打开并创建txt文件//////////////////////////////////char name1[50],name2[50];ifstream infile;cout<<"选择要打开的文件：1019n.txt 1020n.txt 1021n.txt"<<endl;cin>>name1;infile.open(name1,ios::in);/*string contents;*/if(infile.fail()){cout << "error open!" << endl;}cout<<"要保存的文件名："<<endl;cin>>name2;ofstream outfile(name2,ios::out);if(!outfile){cout<<"open eror!"<<endl;exit(1);}//////////////////////访问预处理文件///////////////////////////////////////////// Sales_n sal[10000];int sal_size=0;int ser_size=0;int m = 0,n = 1;int new1[3400][20]={0}; //暂时储存商品IDwhile(!infile.eof()){infile >> sal[sal_size].serial >> sal[sal_size].market >> sal[sal_size].date>> sal[sal_size].sn>> sal[sal_size].id>> sal[sal_size].num>> sal[sal_size].price;sal_size++;}///////////////取统一流水的商品ID前三位按升序无重复的保存起来/////////////////////////new1[0][0]=sal[0].id/10000;for (int i =1;i<sal_size;i++){if (sal[i].serial==sal[i-1].serial){new1[m][n]=sal[i].id/10000; //////流水号相同n++;//outfile<<sal[i].id/100<<'\t';}else{///////排序//////////for(int k = 0;k<n;k++){for(int j = 0;j < n-k-1;j++){if(new1[m][j] > new1[m][j+1]){int t = new1[m][j];new1[m][j] = new1[m][j+1];new1[m][j+1] = t;}}}for(int l= 0;l< n;l++){if(new1[m][l-1]!=new1[m][l])outfile<<new1[m][l]<<'\t';}outfile<<endl;m++;n = 0;new1[m][n]=sal[i].id/10000;n++;}}infile.close();//关闭文件outfile.close();//关闭文件system( "PAUSE ");}2、//Apriori算法挖掘频繁项集support = 2（加注释）#include <iostream>#include <fstream>#include <string>#include <vector>#include <map>#include <cmath>#include <bitset>#include <algorithm>#include <iomanip>using namespace std;const int minsup=2; //设置最小支持度map<string,int> items_count; //统计各个项集的数目vector<string> mergeItem(vector<string> vect1,vector<string> vect2,int round); //合并生成新的候选项集int isExist(vector<string> item,vector<vector<string> >items); //判断项集item是否已经存在候选项集集合items中,存在则返回vector<string> mergeItem(vector<string> vect1,vector<string> vect2,int round) //判断两个项集是否可以合并(要求只有一项不同)成一个新的项集（做为候选集）{////////////////////////////////////////////剪枝工作////int count=0; //统计两个vector中相同的项的数目vector<string> vect;map<string,int> tempMap; //辅助判断两个vector中重复的项for(vector<string>::size_type st=0;st<vect1.size();st++){tempMap[vect1[st]]++;vect.push_back(vect1[st]);}for(int st=0;st<vect2.size();st++){tempMap[vect2[st]]++;if(tempMap[vect2[st]]==2) //表示这两项相同{count++;}else{vect.push_back(vect2[st]);}}if((count+1)!=round) //要求两个项目集只有一个项目不相同，其他都相同 { vect.clear();}return vect;}int isExist(vector<string> item,vector<vector<string> >items) //判断项集item是否已经存在候选项集集合items中,存在则返回{int count; //统计相同的项的数目if(!items.empty()){for(vector<vector<string> >::size_type ix=0;ix!=items.size();ix++){count=0;for(vector<string>::size_type iy=0;iy!=items[ix].size();iy++){for(vector<string>::size_type iz=0;iz!=item.size();iz++){if(item[iz]==items[ix].at(iy)){count++;}}}if(count==item.size()) //表示存在{return 1;}}}return 0;}int main(){vector<vector<string> > datavec; //原始数据项集vector<vector<string> > candidatevec; //候选项集vector<vector<string> > frequentvec; //频繁项集vector<map<string,int> > bitmap; //判断某个项目在某一个事务中是否存在，存在则值为1，反之为0long trancount=0; //原始事务总数char name1[50];ifstream file;cout<<"选择要打开的文件：new1.txt new2.txt new3.txt"<<endl;cin>>name1;file.open(name1,ios::in); //打开数据文件if(!file) //检查文件是否打开成功{cout<<"Fail to open data file!"<<endl;return 1;}else{string temp;vector<string> item; //项集的临时vectorint begin,end;while(getline(file,temp)) //一行一行读入数据{trancount++;begin=0;temp.erase(0,temp.find_first_not_of("\r\t\n ")); //去除字符串首部的空格 temp.erase(temp.find_last_not_of("\r\t\n")+1);while((end=temp.find('\t',begin))!=string::npos) //每一个事务中的项是以'\t'为分隔符的{item.push_back(temp.substr(begin,end-begin)); //将每一个项插入item中 begin=end+1;}item.push_back(temp.substr(begin)); //一个事务中的最后一项datavec.push_back(item); //将一个事务中的所有项当成一个整体插入另一个大的vector中item.clear(); //清空item}cout<<"Press Enter to continue the processing"; //pausegetchar();map<string,int> item_map;for(vector<vector<string> >::size_type ix=0;ix!=datavec.size();++ix){for(vector<string>::size_type iy=0;iy!=datavec[ix].size();++iy){items_count[datavec[ix].at(iy)]++; //该项集的计数加item_map[datavec[ix].at(iy)]=1; //表示该项目在该事务中存在，值为1，否则默认为0}bitmap.push_back(item_map);item_map.clear(); //这里一定要清空一下}map<string,int>::const_iterator map_it=items_count.begin();cout<<"候选项集1:"<<endl;while(map_it!=items_count.end()) //输出候选1项集{cout<<"{"<<map_it->first<<"}"<<endl;map_it++;}cout<<"Press Enter to continue the processing"; //pausegetchar();map_it=items_count.begin();cout<<"频繁1项集(minsup=2):"<<endl;while(map_it!=items_count.end()) //频繁1项集{if(map_it->second>minsup) //支持度大于2{cout.setf(ios::fixed);cout<<"{"<<map_it->first<<"}"<<" 支持度:"<<setprecision(6)<<map_it->second<<endl;item.push_back(map_it->first);frequentvec.push_back(item); //插入候选项集的vector中item.clear();}map_it++;}if(!frequentvec.empty()) //判断频繁项集是否为空，为空则退出{cout<<"Press Enter to continue the processing"; //pausegetchar();int round=1; //生成候选项集轮次int found; //是否包含有非频繁的子集,为表示含有，有的话进行剪枝string tempstr;vector<string> tempvec;do{//生成下一轮的候选项集vector<vector<string> >::size_type st=frequentvec.size();candidatevec.clear(); //清除上一轮的候选项集for(vector<vector<string> >::size_type st1=0;st1<st;st1++){for(vector<vector<string> >::size_type st2=st1+1;st2<st;st2++){found=0;item=mergeItem(frequentvec[st1],frequentvec[st2],round); //调用函数合并生成下一轮的候选项集if(!item.empty()&&!isExist(item,candidatevec)) //若经过判断处理后返回的vector不为空且还不存在该项集，则作为候选项集加入候选vector中 {////////实现剪枝//////////////////////////string teststr;int testint;tempvec=item;sort(tempvec.begin(),tempvec.end());while(next_permutation(tempvec.begin(),tempvec.end())) //遍历所有的组合 {for(vector<string>::size_typetempst=0;tempst!=tempvec.size();tempst++) //拼接出该字符串组合{tempstr+=tempvec[tempst];}for(map<string,int>::const_iteratortempit=items_count.begin();tempit!=items_count.end();tempit++){if(tempit->second<minsup) //非频繁项集{if(tempstr.find(tempit->first)!=string::npos) //表示包含有非频繁子项集{found=1;teststr=tempit->first;testint=tempit->second;break;}}}tempstr.erase();if(found) //包含非频繁子项集{break;}}if(!found) //只有不包含有非频繁子项集才加入候选项集中，否则剪枝掉candidatevec.push_back(item);found=0; //重置}}}frequentvec.clear(); //清除上一轮的频繁项集round++;cout<<"候选"<<round<<"项集:"<<endl;for(vector<vector<string> >::size_type ix=0;ix!=candidatevec.size();++ix) //输出候选项集{cout<<"{";for(vector<string>::size_type iy=0;iy!=candidatevec[ix].size();++iy){cout<<candidatevec[ix].at(iy)<<' ';}cout<<"}"<<endl;}if(candidatevec.empty()) //候选项集为空{cout<<"候选"<<round<<"项集为空!"<<endl;}int flag; //标记某个项集在某条事务中是否出现，出现为1，不出现为0 int count; //统计某个想集在整个交易的事务集中出现的次数string tempstr; //临时string，用于串接各个项成一个字符串int mark; //为避免执行多余的字符串串接工作for(vector<vector<string> >::size_type sx=0;sx!=candidatevec.size();++sx) //构造下一轮的频繁项集{mark=1;count=0;for(vector<map<string,int> >::size_type sy=0;sy!=bitmap.size();++sy){flag=1; //初始化为1，表出现for(vector<string>::size_type sz=0;sz!=candidatevec[sx].size();++sz){if(bitmap[sy][candidatevec[sx].at(sz)]==0) //存在某一个子项不存在，则没出现项集{flag=0;}if(mark==1) //只串接一次{tempstr+=candidatevec[sx].at(sz); //串接字符串}}if(flag) //flag仍然为，表示该项集在该条事务中出现了，计数加{count++;}mark++;}if(count>minsup) //支持度大于2{frequentvec.push_back(candidatevec[sx]); //插入频繁项集}items_count[tempstr]=count; //对应该项集的计数值sort(candidatevec[sx].begin(),candidatevec[sx].end()); //排序string tempstr2;while(next_permutation(candidatevec[sx].begin(),candidatevec[sx].end())) //取下一排列组合{for(vector<string>::size_typetempst=0;tempst!=candidatevec[sx].size();tempst++) //拼接出该字符串组合 {tempstr2+=candidatevec[sx][tempst];}items_count[tempstr2]=count; //对应该项集的计数值tempstr2.erase();}tempstr.erase();}cout<<"Press Enter to continue the processing"; //pausegetchar();if(!frequentvec.empty()) //频繁项集不为空{cout<<"频繁"<<round<<"项集(minsup=2):"<<endl;for(int sx=0;sx!=frequentvec.size();++sx) //输出频繁项集{cout.setf(ios::fixed);cout<<"{";for(vector<string>::size_type sz=0;sz!=frequentvec[sx].size();++sz){cout<<frequentvec[sx].at(sz)<<' ';tempstr+=frequentvec[sx].at(sz); //串接字符串}cout<<"}";cout<<endl;tempstr.erase();}cout<<"Press Enter to continue the processing"; //pausegetchar();}else{cout<<"没有"<<round<<"-频繁项集,Apriori算法结束!"<<endl;}}while(!frequentvec.empty()); //频繁项集不为空,则循环继续file.close();return 0;}else{return 0;} //end of if(!frequentvec.empty())}//end of if(!file)}•实验结果：。
