prefixspan算法java实现Word文件下载.docx
《prefixspan算法java实现Word文件下载.docx》由会员分享，可在线阅读，更多相关《prefixspan算法java实现Word文件下载.docx（15页珍藏版）》请在冰豆网上搜索。
>
sequences=null;
*最大频繁序列
maxFrSeqs=newArrayList<
（）;
*单项集合
itemList=newArrayList<
*单项序列总和数
privateinttotal=0;
*最小支持数（默认两个）
privateintminSup=0;
*最小限制频繁序列元素数（默认两个）
privateintminFrElemSize=0;
*最大限制频繁序列元素数（默认3个）
privateintmaxFrElemSize=0;
publicPrefixSpanBuild（List<
seqs）{
this（seqs,2,2,3）;
}
seqs,intminSup）{
this（seqs,minSup,2,3）;
seqs,intminSup,intminFrElemSize）{
this（seqs,minSup,minFrElemSize,3）;
seqs,intminSup,intminFrElemSize,
intmaxFrElemSize）{
//最小项集必须小于或等于限制项集数
if（minFrElemSize<
=maxFrElemSize）{
this.sequences=seqs;
this.minSup=minSup;
this.minFrElemSize=minFrElemSize;
this.maxFrElemSize=maxFrElemSize;
for（List<
elem:
this.sequences）{
items:
elem）{
for（Stringitem:
items）{
if（!
itemList.contains（item））{
itemList.add（item）;
total++;
计算每个单项的支持数
*@return每个单项的支持数
protectedMap<
String,Integer>
countFr1（）{
log.info（"
开始读取每个单项的支持数"
）;
Map<
supMap=newLinkedHashMap<
//sup计算每个单项出现的次数（支持数）
Integersup=0;
Set<
itemsSet=null;
sequences）{
itemsSet=newHashSet<
itemsSet.addAll（items）;
itemsSet）{
if（itemList.contains（item））{
if（supMap.containsKey（item））{
sup=supMap.get（item）+1;
}else{
sup=1;
supMap.put（item,sup）;
for（Iterator<
Entry<
iter=supMap.entrySet（）.iterator（）;
iter.hasNext（）;
）{
Entry<
supEntry=（Entry<
）iter.next（）;
sup=supEntry.getValue（）;
if（sup<
minSup）{
iter.remove（）;
total=supMap.size（）;
读取完毕"
returnsupMap;
publicList<
replace（List<
strList,String[]prefixSeq）{
List<
retainList=null;
inti=strList.size（）;
intlength=prefixSeq.length;
intpla=strList.indexOf（prefixSeq[length-1]）;
if（pla>
=0&
&
pla<
i-1）{
retainList=newArrayList<
if（length==1）{
retainList.add（"
_"
for（intk=0;
k<
=pla;
k++）{
retainList.addAll（strList.subList（pla+1,i））;
returnretainList;
temp_s在其投影数据库中查找再次出现他的次数
*@paramt_num序列总数
*@paramtemps序列
*@paramsd[]投影数据库
*@paramsd_count[]对应的索引
*@returnint
publicintmakeout（Stringtemps,List<
sdSeqs）{
returnmakeout（newString[]{temps},sdSeqs）;
*@paramtempSeq序列
*@paramsdSeqs投影数据库
publicintmakeout（String[]tempSeq,List<
String[]tempsSeqClone=tempSeq.clone（）;
inttMincout=0;
sdElem:
sdItems:
sdElem）{
intn=-1;
n=containArrays（sdItems,tempsSeqClone）;
if（n>
=0）{
tMincout++;
break;
returntMincout;
用PrefixSpan算法求出序列集的频繁序列
protectedvoidprefixSpan（String[]prefixSeq,List<
seqs,intprefixNum）{
//如果前缀得出的子序列的长度大于maxFrElemSize,则直接跳出
if（prefixNum>
this.maxFrElemSize-1）{
return;
for（inttTotal=0;
tTotal<
total;
tTotal++）{
//第一种情况a的投影数据库seqs,循环整个单项集合ItemList,看是否存在某个item在seqs上还存在频繁单项eg:
<
a>
b>
intsupNum1=0;
StringtempSeq=itemList.get（tTotal）;
supNum1=makeout（tempSeq,seqs）;
if（supNum1>
=minSup）{
//开始记录频繁序列
=this.minFrElemSize-1）{
for（inti=0;
i<
prefixNum;
i++）{
itemList.add（prefixSeq[i]）;
itemList.add（tempSeq）;
//添加支持数
itemList.add（supNum1+"
"
//添加置信度
itemList.add（（float）supNum1/seqs.size（）+"
maxFrSeqs.add（itemList）;
sdSeqs=generateSD（seqs,tempSeq）;
StringprefixSeq2[]=newString[prefixNum+1];
for（inte=0;
e<
e++）
prefixSeq2[e]=prefixSeq[e];
prefixSeq2[prefixNum]=tempSeq;
prefixSpan（prefixSeq2,sdSeqs,prefixNum+1）;
//第二种情况a和ItemList的某个单项进行组合,看是否在seqs是还存在大于最小支持数的itemeg:
a,b>
intsupNum2=0;
StringtempSeq1=prefixSeq[prefixNum-1]+"
"
+itemList.get（tTotal）;
StringtempSeq1s[]=tempSeq1.split（"
supNum2=makeout（tempSeq1s,seqs）;
if（supNum2>
=this.minFrElemSize）{
prefixNum-1;
itemList.add（tempSeq1）;
itemList.add（supNum2+"
itemList.add（（float）supNum2/seqs.size（）+"
sdSeqs=generateSD（seqs,tempSeq1s）;
Stringaa[]=newString[prefixNum];
aa[e]=prefixSeq[e];
aa[prefixNum-1]=tempSeq1;
prefixSpan（aa,sdSeqs,prefixNum）;
buildPrefixSpan（）{
supMap=this.countFr1（）;
inttimes=0;
符合支持度为{},项集数为{}的总item数为{}"
newInteger[]{minSup,minFrElemSize,total}）;
StringitemId=null;
for（Entry<
supEntry:
supMap.entrySet（））{
itemId=supEntry.getKey（）;
//生成投影数据库
sdList=this.generateSD（itemId）;
StringprefixSeq[]={itemId};
this.prefixSpan（prefixSeq,sdList,1）;
times++;
执行到itemId-{},已经循环到{}"
newString[]{prefixSeq[0],times+"
}）;
returnthis.maxFrSeqs;
publicstaticvoidmain（String[]args）{
Stringsequence[]={"
a"
"
a,b,c"
a,c"
d"
c,f"
a,d"
d,e"
e,f"
"
a,b"
d,f"
c"
b"
e"
g"
a,f"
};
sLists=newArrayList<
e1=newArrayList<
Stringe=null;
items=null;
5;
e=sequence[i];
if（e!
=null）{
items=newArrayList<
e.split（"
））{
items.add（item）;
Collections.sort（items）;
e1.add（items）;
e2=newArrayList<
for（inti=5;
9;
e2.add（items）;
e3=newArrayList<
for（inti=9;
14;
e3.add（items）;
e4=newArrayList<
for（inti=14;
20;
e4.add（items）;
sLists.add（e1）;
sLists.add（e2）;
sLists.add（e3）;
sLists.add（e4）;
PrefixSpanBuildtest=newPrefixSpanBuild（sLists,2,2）;
test.buildPrefixSpan（）;
System.out.println（"
序列数据库如下：
test.sequences）{
item2s:
System.out.print（item2s）;
System.out.print（"
System.out.println（）;
执行PrefixSpan算法，生成频繁序列模式结果如下：
//System.out.println（tempti）;
test.printMaxFrSeq（）;
publicvoidprintMaxFrSeq（）{
StringBuffertempStrBuf=null;
intseqSize=0;
sequence:
maxFrSeqs）{
tempStrBuf=newStringBuffer（）;
seqSize=sequence.size（）;
tempStrBuf.append（"
seqSize-3;
StringskuId=sequence.get（i）;
tempStrBuf.append（skuId+"
tempStrBuf.append（sequence.get（seqSize-3））;
-"
+sequence.get（seqSize-2））;
+sequence.get（seqSize-1））;
log.info（（（tempStrBuf.toString（））））;
*根据前缀生成投影数据库
*@paramseqs序列数据库S
generateSD（List<
seqs,StringprefixSeq）{
returngenerateSD（seqs,newString[]{prefixSeq}）;
*@paramprefixSeq前缀
generateSD（StringprefixSeq）{
returngenerateSD（sequences,newString[]{prefixSeq}）;
seqs,String[]prefixSeq）{
sdList=newArrayList<
retainItems=null;
sdElem=null;
retainsdElem=null;
sdElem=newArrayList<
intn=containArra
升级会员 