数据挖掘十大经典算法之apriori算法源代码Word格式.docx
《数据挖掘十大经典算法之apriori算法源代码Word格式.docx》由会员分享，可在线阅读，更多相关《数据挖掘十大经典算法之apriori算法源代码Word格式.docx（15页珍藏版）》请在冰豆网上搜索。
VC界面的源代码见
由Agrawal等人提出的Apriori是经典的关联规则和频繁项集挖掘算法，围绕着它的改进和实现有大量的文献。
该算法是挖掘产生布尔关联规则频繁项目集的经典算法，从其产生到现在对关联规则挖掘方面的研究有着很大的影响。
为了提高频繁项目的挖掘效率，Apriori算法利用了两个重要的性质，用于压缩搜索的空间。
【1】若X为频繁项目集，则X的所有子集都是频繁项目集。
【2】若X为非频繁项目集，则X的所有超集均为非频繁项目集。
Apriori算法的处理流程为：
宽度优先搜索整个项集空间，从k=0开始，迭代产生长度为k+1的候选项集的集合Ck+1。
候选项集是其所有子集都是频繁项集的项集。
C1由I0中所有的项构成，在第k层产生所有长度为k+1的项集。
这由两步完成：
第一步，Fk自连接。
将Fk中具有相同（k-1）-前缀的项集连接成长度为k的候选项集。
第二步是剪枝，如果项集的所有长度为k的子集都在Fk中，该项集才能作为候选项集被加入Ck+1中。
为了计算所有长度为k的候选项集的支持度，在数据库水平表示方式下，需要扫描数据库一遍。
在每次扫描中，对数据库中的每条交易记录，为其中所包含的所有候选k-项集的支持度计数加1。
所有频繁的k-项集被加入Fk中。
此过程直至Ck+1等于空集时结束。
算法
Apriori
Input:
TransactionDataBase
D，Minimumsupportthreshold
minsup。
Output：
Frequentpattern
L
（1）
L1=search_frequent_1-itemsets（D）;
（2）
for（k=2;
Lk-1≠φ;
k++）
do
（3）
begin
（4）
Ck=apriori-gen（Lk-1）;
（5）
forall
transactions
t
D
（6）
（7）
Ct=subset（Ck，t）;
（8）
candidatesc
Ct
（9）
c.count++;
（10）
end
（11）
Lk
={c
Ck|c.count≥minsup}
（12）
（13）Answer
L=∪kLk;
ProcedureSearch_frequent_1-itemsets（D）
foreachitem
ik
ik.count++;
L1
={
i
I
|
i.count≥minsup}
return
L1;
Procedureapriori_gen（Lk）
for
each
itemset
l1
l2
if
（
l1[1]=l2[1]）
l1[2]=l2[2]）
…
l1[k-1]=l2[k-1]）
l1[k]<
l2[k]）
then
c=
l2;
Is_include_infrenquent_subset（c,Lk）
delete
c;
else
add
c
to
Ck+1
;
（13）
（14）
ProcedureIs_include_infrenquent_subset（c,Lk）
（1）begin
foreach
k-subset
s
of
c
retureTURE;
returnFALSE
（6）end
在主程序中，第一步首先扫描整个交易数据库D，统计每个项目（item）的支持数，计算其支持度，将支持度大于等于最小支持度minsup的项目构成的集合放入到L1
中；
从第2步到第11步，用k-1频繁项目集构成的Lk-1生成候选集的集合Ck，以便从中生成Lk，其中apriori_gen函数（第4步）用来从Lk-1中生成Ck，然后对数据库进行扫描（第5步），对于数据库中的每一个交易，subset函数用来发现此交易包含的所有候选集（第7步），并为这些候选集的计数器加1（第8-9步）。
最后满足minsup的候选集被放入到Lk中。
apriori_gen过程完成两种操作：
并（join）和剪枝（prune）。
在并运算步骤中，Lk-1
与Lk-1
进行并运算生成潜在的候选集（2-7步），条件l1[k-1]<
l2[k-1]保证不会有重复的候选集生成（第5步）。
在剪枝步骤中（8-10步），利用性质2.1，删除那些存在子集不是频繁项目集的候选集，测试子集是否为频繁项目集由过程Is_include_infrenquent_subset完成。
为了清楚的阐述Apriori算法的挖掘过程，现举例如下：
【例1】设事务数据库D如表2.1所示，D中包含4个事务，即|D|=4，最小支持数mincount=2，即最小支持度minsup=2/4=50%。
挖掘频繁项目集的具体过程如下所述：
C1={{A},{B},{C},{D},{F}}，第一次循环产生L1={{A},{B},{C},{F}}，由Apriori_gen（L1）生成C2，扫描数据库，计算C2中每个候选集得到L2。
依此循环，得到L3。
整个挖掘过程如图2.1所示。
表1
事务数据库D
Tid
事务
100
200
300
400
B,C,F
A,C,D
B,F
A,B,C,F
图1Apriori算法的执行过程
在找到了事务数据库中的所有频繁项集后，利用这些频繁项集可以产生关联规则，产生关联规则的步骤如下：
对于每个频繁项目集l，产生l的所有非空子集。
对于l的每个非空子集m，如果support（l）/support（m）≥minconf，则输出规则“m
（l-m）”。
例如，在上例中产生的频繁项目集l＝{B,C,F}，l的非空子集有{B,C}、{B,F}、{C,F}、{B}、{C}和{F}，则运用上述产生关联规则的方法可以得到以下关联规则：
B
C
F
confidence=（2/4）/（4/4）=1
confidence=（2/4）/（3/4）=0.667
confidence=（2/4）/（2/4）=1
confidence=（2/4）/（3/4）=0.667
源代码
apriori.c
//////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
#include<
stdio.h>
typedef
struct
{
intitem[100];
//数据项
}D_Node;
//数据库D
//数据项,用item[0]保存支持度
}C_Node;
//候选集
}L_Node;
//频繁集
C_NodeC[100][100];
L_NodeL[100][100];
D_NodeD[100];
intmin_supp;
//最小支持度
void
InPut（）
inti,j,n,n1;
printf（"
请输入最小支持度:
"
）;
scanf（"
%d"
&
min_supp）;
请输入交易集的大小"
D[0].item[0]）;
n=D[0].item[0];
for（i=1;
i<
=n;
i++）
//for1
{
请输入交易[%d]中记录的个数（n）"
i）;
n1）;
D[i].item[0]=n1;
for（j=1;
j<
=n1;
j++）
//for2
请输入交易[%d]中记录项，直接输入数字:
D[i].item[j]）;
}//for2
}
}//endofInPut
C1（）
//功能：
扫描数据集D生成1项候选集C1
//输入：
数据集D
//输出1项候选集C1
//初始条件数据集D非空
inti,j,k;
intno=1,temp=0;
C[1][0].item[0]=0;
//1项集的个数，在本算法中，用C[n][k].item[0]来保存候选集Cn的第k项的支持度
if（D[0].item[0]!
=0）
C[1][1].item[1]=D[1].item[1];
}
=D[0].item[0];
//for1
=D[i].item[0];
//for2
升级会员 