下载文档原格式
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、理解频繁模式和关联规则2、掌握频繁模式挖掘算法Apriori3、为改进Apriori打下基础二、实验内容1、选定一个数据集（可以参考教学中使用的数据集）2、选择合适的实现环境和工具实现算法，本次试验采用的是C++3、根据设置的最小支持度和置信度，给出数据集的频繁模式集三、实验原理该算法的基本思想是：Apriori使用一种称作逐层搜索的迭代方法，k项集用于探索（k+1）项集。
首先，通过扫描数据库，累积每个项的计数，并收集满足最小支持度的项，找出频繁1项集的集合。
该集合记作L1.然后，L1用于找频繁2项集的集合L2，L2用于找L3，如此迭代，直到不能再找到频繁k项集。
找每个Lk需要一次数据库全扫描。
Apriori性质：频繁项集的所有非空子集也必是频繁的。
Apriori算法主要包括连接步和剪枝步两步组成。
在连接步和剪枝步中采用Apriori性质可以提高算法的效率。
四、实验要求1、数据集具有一定的代表性，可以使用数据库技术管理2、最小支持度和置信度可以设置3、实现界面友好4、提交实验报告：实验题目、目的、数据集描述、实验环境、过程、结果和分析等。
五、实验步骤1、所采用的数据集对于数据集，取最小支持度min_sup=2，最小置信度min_conf=0.8。
2、算法步骤①首先单趟扫描数据集，计算各个一项集的支持度，根据给定的最小支持度闵值，得到一项频繁集L1。
②然后通过连接运算，得到二项候选集，对每个候选集再次扫描数据集，得出每个候选集的支持度，再与最小支持度比较。
得到二项频繁集L2。
③如此进行下去，直到不能连接产生新的候选集为止。
④由频繁项集产生关联规则，关联规则产生步骤如下：1）对于每个频繁项集l，产生其所有非空真子集；2）对于每个非空真子集s,如果support_count(l)/support_count(s)>=min_conf，则输出 s->(l-s)，其中，min_conf是最小置信度阈值。
Apriori算法实验报告一、引言在数据挖掘领域，频繁项集挖掘是一项重要任务。
频繁项集指的是在一组交易记录中经常一起出现的物品集合。
Apriori算法是一种常用的频繁项集挖掘算法，其基本思想是通过迭代的方式逐渐生成和验证候选集合，从而找到频繁项集。
二、实验设计本实验旨在通过实际运用Apriori算法来挖掘某个购物网站的交易数据，从中发现频繁项集和关联规则。
实验数据集包含了一定数量的交易记录，每条记录包含了购买的商品列表。
我们将使用Python语言实现Apriori算法，并采用适当的数据结构和算法优化来提高运行效率。
三、数据预处理在进行频繁项集挖掘之前，我们首先需要对原始数据进行处理。
具体而言，需要将购买的商品列表进行编码，将商品名称映射为整数。
此外，还需要去除交易记录中的重复项，以减少数据的冗余性。
经过数据预处理后，我们得到了处理后的数据集。
四、Apriori算法实现首先，我们需要初始化候选集合。
将每个商品作为项集的初始候选项，并遍历整个数据集得到每个初始候选项的支持度。
根据设定的最小支持度阈值，过滤掉低频项，得到频繁1项集。
接下来，我们使用频繁1项集生成候选2项集。
具体而言，我们对于每个频繁1项集，两两组合，得到候选2项集，并计算其支持度。
同样根据最小支持度阈值，过滤掉低频项，得到频繁2项集。
然后，我们采用逐层迭代的方式生成更高阶的候选项集。
具体而言，我们使用频繁k-1项集生成候选k项集，然后计算其支持度，并过滤掉低频项，得到频繁k项集。
重复迭代，直到无法生成更高阶的候选项集为止。
最后，我们根据频繁项集生成关联规则。
具体而言，对于每个频繁项集，我们生成其所有非空子集，并计算其置信度。
根据设定的最小置信度阈值，过滤掉低置信度的关联规则，得到满足要求的关联规则。
五、实验结果分析经过实验运行，我们得到了购物网站交易数据的频繁项集和关联规则。
我们对实验结果进行分析如下：1. 频繁项集通过观察频繁项集，我们可以发现一些有趣的规律。
数据挖掘中频繁模式挖掘算法的使用教程数据挖掘是一种从大量数据中自动发现模式并提取有用信息的过程。
频繁模式挖掘算法是数据挖掘中常用的一种算法，它帮助我们发现数据集中出现频繁的项集或序列，从而揭示数据中潜在的关联性。
本文将介绍一些常用的频繁模式挖掘算法，并详细讨论它们的工作原理和使用方法。
1. Apriori算法Apriori算法是一种经典的频繁模式挖掘算法。
它基于一种称为“先验性质”的思想，通过迭代扫描数据集来发现频繁项集。
具体步骤如下：- 初始化频繁一项集集合，即单个项的集合；- 生成候选项集，并计算其支持度，筛选出频繁项集；- 基于频繁项集生成新的候选项集，重复上述步骤，直到无法继续生成新的候选项集。
Apriori算法的优点是简单易懂，但对大规模数据集的性能较差。
对于大型数据集，效率改进的Apriori改进算法，如FP-Growth算法，可以更快地挖掘频繁项集。
2. FP-Growth算法FP-Growth算法是一种基于频繁模式挖掘的高效算法。
与Apriori算法相比，FP-Growth算法通过构建FP树来表示数据集，避免了多次扫描数据集的开销，从而提升了性能。
具体步骤如下：- 构建FP树，同时记录每个项的频率；- 根据FP树构建条件模式基；- 递归地从条件模式基中构建FP树，并挖掘频繁项集。
FP-Growth算法的优点是在大规模数据集上具有较高的挖掘效率，但它需要占用较大的内存空间。
3. Eclat算法Eclat算法是一种基于集合的频繁模式挖掘算法。
它通过垂直数据格式表示数据集，并使用位图位级运算来计算频繁项集。
具体步骤如下：- 根据事务数据生成垂直数据格式；- 递归地计算出现频繁的项的集合；- 计算交集，生成更长的频繁项集。
Eclat算法的优点是在较小的数据集上表现良好，并且不需要占用大量的内存空间，但它在处理大规模数据集时性能较差。
4. PrefixSpan算法PrefixSpan算法是一种基于序列的频繁模式挖掘算法。
Apriori算法是一种关联规则挖掘算法，由Rakesh Agrawal和Ramakrishnan Srikant在1994年提出。
关联规则的目的在于在一个数据集中找出项与项之间的关系。
Apriori算法广泛应用于商业、网络安全等领域。
实验总结：1. 实验目的：通过使用Apriori算法对交易数据集进行关联规则挖掘，以发现频繁项集和关联规则。
2. 实验步骤：2.1 数据准备：首先，需要准备一个交易数据集，包含交易记录。
每条记录表示一次交易，包含多个项目（商品）。
2.2 数据预处理：将交易数据集转换为适合Apriori算法处理的形式。
例如，将交易记录存储为事务列表，每个事务由一组项目组成。
2.3 设定参数：根据实验需求设定最小支持度（minSup）和最小置信度（minConf），用于控制挖掘出的频繁项集和关联规则的阈值。
2.4 生成候选项集：使用Apriori算法生成频繁项集的候选项集，包括频繁1-项集、频繁2-项集等。
2.5 计算支持度：对每个候选项集计算其在交易数据集中的支持度，筛选出满足最小支持度的频繁项集。
2.6 生成关联规则：根据频繁项集生成关联规则，并计算其置信度。
若关联规则的置信度满足最小置信度，则保留该规则。
2.7 结果输出：将挖掘出的频繁项集和关联规则进行输出，以便进一步分析。
3. 实验结果：通过实验可以发现，Apriori算法能够有效地挖掘出交易数据集中的频繁项集和关联规则。
实验结果可以为商业决策提供有价值的参考信息，如商品之间的价格关系、促销策略等。
4. 实验总结：Apriori算法在关联规则挖掘中具有较强的实用价值，能够快速、准确地发现数据集中的频繁项集和关联规则。
在实际应用中，根据具体需求设定合适的参数，可挖掘出有意义的关联信息，为决策制定提供支持。
同时，实验过程中需要注意数据预处理、参数设定等环节，以提高实验结果的准确性和实用性。
实验一、Apriori算法发现频繁项集一、实验目的：1) 进一步熟悉Matlab编程算法；2) 掌握使用Apriori算法从事物数据库中挖掘频繁项集的方法。
二、实验原理：1、Apriori算法Apriori使用一种称作逐层搜索的迭代方法，k项集用于探索（k+1）项集。
首先，通过扫描数据库，累计每个项的计数，并收集满足最小支持度的项，找出频繁1项集的集合。
该集合记作L1。
然后，L1用于找频繁2项集的集合L2，L2用于找L3，如此下去，直到不能再找到频繁k项集。
找每个Lk需要一次数据库全扫描。
2、提高频繁项集逐层产生的效率Apriori性质：频繁项集的所有非空子集也必须是频繁的。
三、实验内容：1、程序框图2、实验内容1) 使用Apriori算法编程实现对实验数据中提供的AllElectronics某分店的事物数据库挖掘频繁项集，并在实验报告中写出程序框图；2) 产生全部频繁模式，保留其中的闭频繁项集。
3) 在实验报告中写明各主要程序片段的功能和作用。
3、实验步骤1) 算法第一次迭代，每项都是候选1项集的集合C1的成员，简单的扫描所有的事物，对每项的出现次数计数；2) 按先验的最小支持度计数阈值min_sup=2，确定频繁1项集的集合L1，令i=1，N i是Li中项的数量；3) 调用子函数Join_Prune(Li,min_sup)，存储频繁项集L i；子函数Join_Prune(Li,min_sup)：a) 对频繁i项集L i执行连接步，产生候选i+1项集C i+1；b) 对候选i+1项集C i+1执行剪枝步，产生频繁i+1项集L i+1；c) 返回频繁i+1项集L i+1。
4) 如果N i+1>0，则令i=i+1，转到步骤3)；否则，算法结束。
4、实验数据AllElectronics某分店的事物数据TID 商品ID的列表T100 I1,I2,I5T200 I2,I4T300 I2,I3T400 I1,I2,I4T500 I1,I3T600 I2,I3T700 I1,I3T800 I1,I2,I3,I5T900 I1,I2,I35、实验代码：function [C]=ExamDM1(AllETrans)[M,N]=size(AllETrans);Ni=5;for i=1:NiCC{i,1}=zeros(1,2);endfor k=1:N[Mk,Nk]=size( AllETrans{k});for i=1:NkCC{AllETrans{k}(i),1}( 1,1)=AllETrans{k}(i);CC{AllETrans{k}(i),1}( 1,2)=CC{AllETrans{k}(i),1}( 1,2)+1;endendC{1,1}=CC;NC=1;[MC2,NC2]=size(C{1,1});min_sup=2;while NC<=NiNCif MC2>=2[C1NC,MC2]=Link(C{1,NC},Ni); % Link step.[CC1NC]=ScanCount(C1NC,AllETrans,N,Ni); % Scanning the transaction database to count the support number.[MC3,NC3]=size(CC1NC);NC=NC+1;kk=0;for k=1:MC3 % Prone step.[MC4,NC4]=size(C1NC{k,1});if CC1NC{k,1}(1,NC4)>=min_supkk=kk+1;C{1,NC}{kk,1}=CC1NC{k,1};endendelseNC=Ni+10;endend% The following is "link" function.function [C1NC,MC2]=Link(C1,Ni)[MC1,NC1]=size(C1);% C1NC{1,1}=zeros(1,NC1+1);MC2=0;for i=1:MC1-1i[MC1i,NC1i]=size(C1{i,1});Ii=zeros(1,Ni);for ii=1:NC1i-1Ii(C1{i,1}(ii))=1;2endfor j=i+1:MC1j[MC1j,NC1j]=size(C1{j,1});for jj=1:NC1j-1Ij(C1{j,1}(jj))=1;endI=Ii+Ij;N12=zeros(1,2);NC2=0;C12=zeros(1,1);for k=1:Niif I(k)>=1N12(1)=N12(1)+1;NC2=NC2+1;C12(1,NC2)=k;endif I(k)>=2N12(2)=N12(2)+1;endendC12(1,NC2+1)=0;if N12(1)-N12(2)==2MC2=MC2+1;C1N{MC2,1}=C12(1,:);endendendC1NC{1,1}=C1N{1,1};MC1NC=1;if MC2>=2for i=2:MC2KM=1;for j=1:MC1NCKM=KM*sum(abs(C1N{i,1}-C1NC{j,1}));endif KM~=0MC1NC=MC1NC+1;C1NC{MC1NC,1}=C1N{i,1}endendend%------------------------------------------------------------------------function [CC1NC]=ScanCount(C1NC,AllETrans,N,Ni)[MC,NC]=size(C1NC);for k=1:N[Mk,Nk]=size(AllETrans{k});for kk=1:NkIScCo(AllETrans{k}(kk))=1;endfor kk=1:MC[MCi,NCi]=size(C1NC{kk});C1NCkk1NCi=IScCo(C1NC{kk}(1));if NCi>2for i=2:NCi-1C1NCkk1NCi=C1NCkk1NCi*IScCo(C1NC{kk}(i));endC1NC{kk}(1,NCi)=C1NC{kk}(1,NCi)+C1NCkk1NCi;endendendCC1NC=C1NC;四、实验结果：实验二使用FP增长算法挖掘频繁项集一、实验目的1) 进一步熟悉Matlab编程环境；2) 掌握使用频繁模式（FP）增长算法从事物数据库中挖掘频繁项集的方法。
Apriori算法及其在关联规则挖掘中的应用关联规则挖掘是数据挖掘的重要领域之一，旨在从大规模数据集中发现隐藏在其中的数据模式。
其中，Apriori算法是关联规则挖掘中最基础和常用的算法之一，其原理和应用范围对于掌握关联规则挖掘的基础知识至关重要。
Apriori算法的原理Apriori算法的思想非常简单：利用频繁项集的概念，在一个数据集中寻找频繁项集，进而得到关联规则。
所谓频繁项集，是指在事务数据库中出现频率达到最小支持度阈值的项集。
具体来说，算法分为两个步骤：1. 基于最小支持度，生成频繁项集。
通过扫描整个数据集，统计每个项在事务数据库中出现的次数，计算项集的支持度。
若支持度大于预设的最小支持度阈值，则认为该项集为频繁项集。
对于项集{A}，其支持度定义为“包含A的事务的数目除以总事务数的比例”，用符号表示为sup(A)。
2. 基于频繁项集，生成关联规则。
对于频繁项集S，从中产生所有非空子集，针对每个子集计算紧缩信任度。
若该值大于某个阈值，则认为该子集可以产生关联规则。
紧缩信任度的定义为“包含A和B的事务的数目除以仅包含A的事务的数目的比例”，用符号表示为Conf(A->B)。
这里需要注意的是，若A、B均为频繁项集，则AB为频繁项集，AB之间的关联规则也需要基于相同的支持度定义进行计算。
这样，Apriori算法能够泛化到更高维度的数据挖掘领域。
Apriori算法的应用Apriori算法对于挖掘大数据集中的频繁项集和关联规则有广泛的应用。
在行业中，常常用于推荐系统、市场篮子分析和销售预测等领域。
例如，在电商网站上，Apriori算法可以用来推荐相关商品。
当用户浏览某种商品时，系统可以根据该商品出现的频繁项集，挖掘出其他与之相关的商品，并向用户推荐。
这种方法可以极大地提高用户对商品的兴趣度，促进销售。
另外，Apriori算法还可以用于市场篮子分析。
随着时代的发展，市场中出现的商品种类越来越多，消费者的选择也越来越丰富。
实验三、应用 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)}•实验结果：。
