PrefixSpan序列模式挖掘算法

更多数据挖掘代码：https://github.com/linyiqun/DataMiningAlgorithm

介绍

与GSP一样，PrefixSpan算法也是序列模式分析算法的一种，不过与前者不同的是PrefixSpan算法不产生任何的侯选集，在这点上可以说已经比GSP好很多了。PrefixSpan算法可以挖掘出满足阈值的所有序列模式，可以说是非常经典的算法。序列的格式就是上文中提到过的类似于<a, b, （de)>这种的。

算法原理

PrefixSpan算法的原理是采用后缀序列转前缀序列的方式来构造频繁序列的。举个例子，

比如原始序列如上图所示，4条序列，1个序列中好几个项集，项集内有1个或多个元素，首先找出前缀为a的子序列，此时序列前缀为<a>,后缀就变为了：

<wbr style="font-family:simsun; line-height:21px; background-color:rgb(245,242,239)"><span style="font-family:simsun; line-height:21px; background-color:rgb(245,242,239)"><img src="https://img-blog.csdn.net/20150213090738210?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvQW5kcm9pZGx1c2hhbmdkZXJlbg==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" style="border:none; max-width:100%"></span><br></wbr>

"_"下标符代表前缀为a，说明是在项集中间匹配的。这就相当于从后缀序列中提取出1项加入到前缀序列中，变化的规则就是从左往右扫描，找到第1个此元素对应的项，然后做改变。然后根据此规则继续递归直到后续序列不满足最小支持度阈值的情况。所以此算法的难点就转变为了从后缀序列变为前缀序列的过程。在这个过程要分为2种情况，第1种是单个元素项的后缀提前，比如这里的a，对单个项的提前有分为几种情况，比如：

<b a c ad>，就会变为<c ad>，如果a是嵌套在项集中的情况<b c dad r>，就会变为< _d r>，_代表的就是a.如果a在一项的最末尾，此项也会被移除<b c dda r>变为<r>。但是如果是这种情况<_da d d>a包含在下标符中，将会做处理，应该此时的a是在前缀序列所属的项集内的。

还有1个大类的分类就是对于组合项的后缀提取，可以分为2个情况，1个是从_X中寻找，一个从后面找出连续的项集，比如在这里<a>的条件下，找出前缀<(ab)>的后缀序列

第一种在_X中寻找还有没有X=a的情况，因为_已经代表1个a了，还有一个是判断_X ！= _a的情况，从后面的项集中找到包含有连续的aa的那个项集，然后做变换处理，与单个项集的变换规则一致。

算法的递归顺序

想要实现整个的序列挖掘，算法的递归顺序就显得非常重要了。在探索递归顺序的路上还是犯了一些错误的，刚刚开始的递归顺序是<a>---><a a>----><a a a>，假设<a a a>找不到对应的后缀模式时，然后回溯到<a (aa)>进行递归，后来发现这样会漏掉情况，为什么呢，因为如果 <a a >没法进行到<a a a>，那么就不可能会有前缀<a (aa)>,顶多会判断到<(aa)>，从<a a>处回调的。于是我发现了这个问题，就变为了下面这个样子，经测试是对的。：

加入所有的单个元素的类似为a-f,顺序为

<a>，---><a a>.同时<(aa)>，然后<ab>同时<(ab)>，就是在a添加a-f的元素的时候，检验a所属项集添加a-f元素的情况。这样就不会漏掉情况了，用了2个递归搞定了这个问题。这个算法的整体实现可以对照代码来看会理解很多。最后提醒一点，在每次做出改变之后都会判断一下是否满足最小支持度阈值的。

PrefixSpan实例

这里举1个真实一点的例子，下面是输入的初始序列：

挖掘出的所有的序列模式为，下面是一个表格的形式

在<b>的序列模式中少了1个序列模式。可以与后面程序算法测试的结果做对比。

算法的代码实现

代码实现同样以这个为例子，这样会显得更有说服性。

测试数据：

[java] view plain copy print ?

1. bdcbac
2. bfcebfg
3. ahbfabf
4. beced
5. abdbcbade

Sequence.java:

[java] view plain copy print ?

1. packageDataMining_PrefixSpan;
3. importjava.util.ArrayList;
5. /**
6. *序列类
7. *
8. *@authorlyq
9. *
10. */
11. publicclassSequence{
12. //序列内的项集
13. privateArrayList<ItemSet>itemSetList;
15. publicSequence(){
16. this.itemSetList=newArrayList<>();
17. }
19. publicArrayList<ItemSet>getItemSetList(){
20. returnitemSetList;
21. }
23. publicvoidsetItemSetList(ArrayList<ItemSet>itemSetList){
24. this.itemSetList=itemSetList;
25. }
27. /**
28. *判断单一项是否包含于此序列
29. *
30. *@paramc
31. *待判断项
32. *@return
33. */
34. publicbooleanstrIsContained(Stringc){
35. booleanisContained=false;
37. for(ItemSetitemSet:itemSetList){
38. isContained=false;
40. for(Strings:itemSet.getItems()){
41. if(itemSet.getItems().contains("_")){
42. continue;
43. }
45. if(s.equals(c)){
46. isContained=true;
47. break;
48. }
49. }
51. if(isContained){
52. //如果已经检测出包含了，直接挑出循环
53. break;
54. }
55. }
57. returnisContained;
58. }
60. /**
61. *判断组合项集是否包含于序列中
62. *
63. *@paramitemSet
64. *组合的项集，元素超过1个
65. *@return
66. */
67. publicbooleancompoentItemIsContain(ItemSetitemSet){
68. booleanisContained=false;
69. ArrayList<String>tempItems;
70. StringlastItem=itemSet.getLastValue();
72. for(inti=0;i<this.itemSetList.size();i++){
73. tempItems=this.itemSetList.get(i).getItems();
74. //分2种情况查找，第一种从_X中找出x等于项集最后的元素，因为_前缀已经为原本的元素
75. if(tempItems.size()>1&&tempItems.get(0).equals("_")
76. &&tempItems.get(1).equals(lastItem)){
77. isContained=true;
78. break;
79. }elseif(!tempItems.get(0).equals("_")){
80. //从没有_前缀的项集开始寻找，第二种为从后面的后缀中找出直接找出连续字符为ab为同一项集的项集
81. if(strArrayContains(tempItems,itemSet.getItems())){
82. isContained=true;
83. break;
84. }
85. }
87. if(isContained){
88. break;
89. }
90. }
92. returnisContained;
93. }
95. /**
96. *删除单个项
97. *
98. *@params
99. *待删除项
100. */
101. publicvoiddeleteSingleItem(Strings){
102. ArrayList<String>tempItems;
103. ArrayList<String>deleteItems=newArrayList<>();
105. for(ItemSetitemSet:this.itemSetList){
106. tempItems=itemSet.getItems();
107. deleteItems=newArrayList<>();
109. for(inti=0;i<tempItems.size();i++){
110. if(tempItems.get(i).equals(s)){
111. deleteItems.add(tempItems.get(i));
112. }
113. }
115. tempItems.removeAll(deleteItems);
116. }
117. }
119. /**
120. *提取项s之后所得的序列
121. *
122. *@params
123. *目标提取项s
124. */
125. publicSequenceextractItem(Strings){
126. SequenceextractSeq=this.copySeqence();
127. ItemSetitemSet;
128. ArrayList<String>items;
129. ArrayList<ItemSet>deleteItemSets=newArrayList<>();
130. ArrayList<String>tempItems=newArrayList<>();
132. for(intk=0;k<extractSeq.itemSetList.size();k++){
133. itemSet=extractSeq.itemSetList.get(k);
134. items=itemSet.getItems();
135. if(items.size()==1&&items.get(0).equals(s)){
136. //如果找到的是单项，则完全移除，跳出循环
137. extractSeq.itemSetList.remove(k);
138. break;
139. }elseif(items.size()>1&&!items.get(0).equals("_")){
140. //在后续的多元素项中判断是否包含此元素
141. if(items.contains(s)){
142. //如果包含把s后面的元素加入到临时字符数组中
143. intindex=items.indexOf(s);
144. for(intj=index;j<items.size();j++){
145. tempItems.add(items.get(j));
146. }
147. //将第一位的s变成下标符"_"
148. tempItems.set(0,"_");
149. if(tempItems.size()==1){
150. //如果此匹配为在最末端，同样移除
151. deleteItemSets.add(itemSet);
152. }else{
153. //将变化后的项集替换原来的
154. extractSeq.itemSetList.set(k,newItemSet(tempItems));
155. }
156. break;
157. }else{
158. deleteItemSets.add(itemSet);
159. }
160. }else{
161. //不符合以上2项条件的统统移除
162. deleteItemSets.add(itemSet);
163. }
164. }
165. extractSeq.itemSetList.removeAll(deleteItemSets);
167. returnextractSeq;
168. }
170. /**
171. *提取组合项之后的序列
172. *
173. *@paramarray
174. *组合数组
175. *@return
176. */
177. publicSequenceextractCompoentItem(ArrayList<String>array){
178. //找到目标项，是否立刻停止
179. booleanstopExtract=false;
180. Sequenceseq=this.copySeqence();
181. StringlastItem=array.get(array.size()-1);
182. ArrayList<String>tempItems;
183. ArrayList<ItemSet>deleteItems=newArrayList<>();
185. for(inti=0;i<seq.itemSetList.size();i++){
186. if(stopExtract){
187. break;
188. }
190. tempItems=seq.itemSetList.get(i).getItems();
191. //分2种情况查找，第一种从_X中找出x等于项集最后的元素，因为_前缀已经为原本的元素
192. if(tempItems.size()>1&&tempItems.get(0).equals("_")
193. &&tempItems.get(1).equals(lastItem)){
194. if(tempItems.size()==2){
195. seq.itemSetList.remove(i);
196. }else{
197. //把1号位置变为下标符"_"，往后移1个字符的位置
198. tempItems.set(1,"_");
199. //移除第一个的"_"下划符
200. tempItems.remove(0);
201. }
202. stopExtract=true;
203. break;
204. }elseif(!tempItems.get(0).equals("_")){
205. //从没有_前缀的项集开始寻找，第二种为从后面的后缀中找出直接找出连续字符为ab为同一项集的项集
206. if(strArrayContains(tempItems,array)){
207. //从左往右找出第一个给定字符的位置，把后面的部分截取出来
208. intindex=tempItems.indexOf(lastItem);
209. ArrayList<String>array2=newArrayList<String>();
211. for(intj=index;j<tempItems.size();j++){
212. array2.add(tempItems.get(j));
213. }
214. array2.set(0,"_");
216. if(array2.size()==1){
217. //如果此项在末尾的位置，则移除该项，否则进行替换
218. deleteItems.add(seq.itemSetList.get(i));
219. }else{
220. seq.itemSetList.set(i,newItemSet(array2));
221. }
222. stopExtract=true;
223. break;
224. }else{
225. deleteItems.add(seq.itemSetList.get(i));
226. }
227. }else{
228. //这种情况是处理_X中X不等于最后一个元素的情况
229. deleteItems.add(seq.itemSetList.get(i));
230. }
231. }
233. seq.itemSetList.removeAll(deleteItems);
235. returnseq;
236. }
238. /**
239. *深拷贝一个序列
240. *
241. *@return
242. */
243. publicSequencecopySeqence(){
244. SequencecopySeq=newSequence();
245. ItemSettempItemSet;
246. ArrayList<String>items;
248. for(ItemSetitemSet:this.itemSetList){
249. items=(ArrayList<String>)itemSet.getItems().clone();
250. tempItemSet=newItemSet(items);
251. copySeq.getItemSetList().add(tempItemSet);
252. }
254. returncopySeq;
255. }
257. /**
258. *获取序列中最后一个项集的最后1个元素
259. *
260. *@return
261. */
262. publicStringgetLastItemSetValue(){
263. intsize=this.getItemSetList().size();
264. ItemSetitemSet=this.getItemSetList().get(size-1);
265. size=itemSet.getItems().size();
267. returnitemSet.getItems().get(size-1);
268. }
270. /**
271. *判断strList2是否是strList1的子序列
272. *
273. *@paramstrList1
274. *@paramstrList2
275. *@return
276. */
277. publicbooleanstrArrayContains(ArrayList<String>strList1,
278. ArrayList<String>strList2){
279. booleanisContained=false;
281. for(inti=0;i<strList1.size()-strList2.size()+1;i++){
282. isContained=true;
284. for(intj=0,k=i;j<strList2.size();j++,k++){
285. if(!strList1.get(k).equals(strList2.get(j))){
286. isContained=false;
287. break;
288. }
289. }
291. if(isContained){
292. break;
293. }
294. }
296. returnisContained;
297. }
298. }

ItemSet.java：

[java] view plain copy print ?

1. packageDataMining_PrefixSpan;
3. importjava.util.ArrayList;
5. /**
6. *字符项集类
7. *
8. *@authorlyq
9. *
10. */
11. publicclassItemSet{
12. //项集内的字符
13. privateArrayList<String>items;
15. publicItemSet(String[]str){
16. items=newArrayList<>();
17. for(Strings:str){
18. items.add(s);
19. }
20. }
22. publicItemSet(ArrayList<String>itemsList){
23. this.items=itemsList;
24. }
26. publicItemSet(Strings){
27. items=newArrayList<>();
28. for(inti=0;i<s.length();i++){
29. items.add(s.charAt(i)+"");
30. }
31. }
33. publicArrayList<String>getItems(){
34. returnitems;
35. }
37. publicvoidsetItems(ArrayList<String>items){
38. this.items=items;
39. }
41. /**
42. *获取项集最后1个元素
43. *
44. *@return
45. */
46. publicStringgetLastValue(){
47. intsize=this.items.size();
49. returnthis.items.get(size-1);
50. }
51. }

PrefixSpanTool.java：

[java] view plain copy print ?

1. packageDataMining_PrefixSpan;
3. importjava.io.BufferedReader;
4. importjava.io.File;
5. importjava.io.FileReader;
6. importjava.io.IOException;
7. importjava.util.ArrayList;
8. importjava.util.Collections;
9. importjava.util.HashMap;
10. importjava.util.Map;
12. /**
13. *PrefixSpanTool序列模式分析算法工具类
14. *
15. *@authorlyq
16. *
17. */
18. publicclassPrefixSpanTool{
19. //测试数据文件地址
20. privateStringfilePath;
21. //最小支持度阈值比例
22. privatedoubleminSupportRate;
23. //最小支持度，通过序列总数乘以阈值比例计算
24. privateintminSupport;
25. //原始序列组
26. privateArrayList<Sequence>totalSeqs;
27. //挖掘出的所有序列频繁模式
28. privateArrayList<Sequence>totalFrequentSeqs;
29. //所有的单一项，用于递归枚举
30. privateArrayList<String>singleItems;
32. publicPrefixSpanTool(StringfilePath,doubleminSupportRate){
33. this.filePath=filePath;
34. this.minSupportRate=minSupportRate;
35. readDataFile();
36. }
38. /**
39. *从文件中读取数据
40. */
41. privatevoidreadDataFile(){
42. Filefile=newFile(filePath);
43. ArrayList<String[]>dataArray=newArrayList<String[]>();
45. try{
46. BufferedReaderin=newBufferedReader(newFileReader(file));
47. Stringstr;
48. String[]tempArray;
49. while((str=in.readLine())!=null){
50. tempArray=str.split("");
51. dataArray.add(tempArray);
52. }
53. in.close();
54. }catch(IOExceptione){
55. e.getStackTrace();
56. }
58. minSupport=(int)(dataArray.size()*minSupportRate);
59. totalSeqs=newArrayList<>();
60. totalFrequentSeqs=newArrayList<>();
61. SequencetempSeq;
62. ItemSettempItemSet;
63. for(String[]str:dataArray){
64. tempSeq=newSequence();
65. for(Strings:str){
66. tempItemSet=newItemSet(s);
67. tempSeq.getItemSetList().add(tempItemSet);
68. }
69. totalSeqs.add(tempSeq);
70. }
72. System.out.println("原始序列数据：");
73. outputSeqence(totalSeqs);
74. }
76. /**
77. *输出序列列表内容
78. *
79. *@paramseqList
80. *待输出序列列表
81. */
82. privatevoidoutputSeqence(ArrayList<Sequence>seqList){
83. for(Sequenceseq:seqList){
84. System.out.print("<");
85. for(ItemSetitemSet:seq.getItemSetList()){
86. if(itemSet.getItems().size()>1){
87. System.out.print("(");
88. }
90. for(Strings:itemSet.getItems()){
91. System.out.print(s+"");
92. }
94. if(itemSet.getItems().size()>1){
95. System.out.print(")");
96. }
97. }
98. System.out.println(">");
99. }
100. }
102. /**
103. *移除初始序列中不满足最小支持度阈值的单项
104. */
105. privatevoidremoveInitSeqsItem(){
106. intcount=0;
107. HashMap<String,Integer>itemMap=newHashMap<>();
108. singleItems=newArrayList<>();
110. for(Sequenceseq:totalSeqs){
111. for(ItemSetitemSet:seq.getItemSetList()){
112. for(Strings:itemSet.getItems()){
113. if(!itemMap.containsKey(s)){
114. itemMap.put(s,1);
115. }
116. }
117. }
118. }
120. Stringkey;
121. for(Map.Entryentry:itemMap.entrySet()){
122. count=0;
123. key=(String)entry.getKey();
124. for(Sequenceseq:totalSeqs){
125. if(seq.strIsContained(key)){
126. count++;
127. }
128. }
130. itemMap.put(key,count);
132. }
134. for(Map.Entryentry:itemMap.entrySet()){
135. key=(String)entry.getKey();
136. count=(int)entry.getValue();
138. if(count<minSupport){
139. //如果支持度阈值小于所得的最小支持度阈值，则删除该项
140. for(Sequenceseq:totalSeqs){
141. seq.deleteSingleItem(key);
142. }
143. }else{
144. singleItems.add(key);
145. }
146. }
148. Collections.sort(singleItems);
149. }
151. /**
152. *递归搜索满足条件的序列模式
153. *
154. *@parambeforeSeq
155. *前缀序列
156. *@paramafterSeqList
157. *后缀序列列表
158. */
159. privatevoidrecursiveSearchSeqs(SequencebeforeSeq,
160. ArrayList<Sequence>afterSeqList){
161. ItemSettempItemSet;
162. SequencetempSeq2;
163. SequencetempSeq;
164. ArrayList<Sequence>tempSeqList=newArrayList<>();
166. for(Strings:singleItems){
167. //分成2种形式递归，以<a>为起始项，第一种直接加入独立项集遍历<a,a>,<a,b><a,c>..
168. if(isLargerThanMinSupport(s,afterSeqList)){
169. tempSeq=beforeSeq.copySeqence();
170. tempItemSet=newItemSet(s);
171. tempSeq.getItemSetList().add(tempItemSet);
173. totalFrequentSeqs.add(tempSeq);
175. tempSeqList=newArrayList<>();
176. for(Sequenceseq:afterSeqList){
177. if(seq.strIsContained(s)){
178. tempSeq2=seq.extractItem(s);
179. tempSeqList.add(tempSeq2);
180. }
181. }
183. recursiveSearchSeqs(tempSeq,tempSeqList);
184. }
186. //第二种递归为以元素的身份加入最后的项集内以a为例<(aa)>,<(ab)>,<(ac)>...
187. //a在这里可以理解为一个前缀序列，里面可能是单个元素或者已经是多元素的项集
188. tempSeq=beforeSeq.copySeqence();
189. intsize=tempSeq.getItemSetList().size();
190. tempItemSet=tempSeq.getItemSetList().get(size-1);
191. tempItemSet.getItems().add(s);
193. if(isLargerThanMinSupport(tempItemSet,afterSeqList)){
194. tempSeqList=newArrayList<>();
195. for(Sequenceseq:afterSeqList){
196. if(seq.compoentItemIsContain(tempItemSet)){
197. tempSeq2=seq.extractCompoentItem(tempItemSet
198. .getItems());
199. tempSeqList.add(tempSeq2);
200. }
201. }
202. totalFrequentSeqs.add(tempSeq);
204. recursiveSearchSeqs(tempSeq,tempSeqList);
205. }
206. }
207. }
209. /**
210. *所传入的项组合在所给定序列中的支持度是否超过阈值
211. *
212. *@params
213. *所需匹配的项
214. *@paramseqList
215. *比较序列数据
216. *@return
217. */
218. privatebooleanisLargerThanMinSupport(Strings,ArrayList<Sequence>seqList){
219. booleanisLarge=false;
220. intcount=0;
222. for(Sequenceseq:seqList){
223. if(seq.strIsContained(s)){
224. count++;
225. }
226. }
228. if(count>=minSupport){
229. isLarge=true;
230. }
232. returnisLarge;
233. }
235. /**
236. *所传入的组合项集在序列中的支持度是否大于阈值
237. *
238. *@paramitemSet
239. *组合元素项集
240. *@paramseqList
241. *比较的序列列表
242. *@return
243. */
244. privatebooleanisLargerThanMinSupport(ItemSetitemSet,
245. ArrayList<Sequence>seqList){
246. booleanisLarge=false;
247. intcount=0;
249. if(seqList==null){
250. returnfalse;
251. }
253. for(Sequenceseq:seqList){
254. if(seq.compoentItemIsContain(itemSet)){
255. count++;
256. }
257. }
259. if(count>=minSupport){
260. isLarge=true;
261. }
263. returnisLarge;
264. }
266. /**
267. *序列模式分析计算
268. */
269. publicvoidprefixSpanCalculate(){
270. Sequenceseq;
271. SequencetempSeq;
272. ArrayList<Sequence>tempSeqList=newArrayList<>();
273. ItemSetitemSet;
274. removeInitSeqsItem();
276. for(Strings:singleItems){
277. //从最开始的a,b,d开始递归往下寻找频繁序列模式
278. seq=newSequence();
279. itemSet=newItemSet(s);
280. seq.getItemSetList().add(itemSet);
282. if(isLargerThanMinSupport(s,totalSeqs)){
283. tempSeqList=newArrayList<>();
284. for(Sequences2:totalSeqs){
285. //判断单一项是否包含于在序列中，包含才进行提取操作
286. if(s2.strIsContained(s)){
287. tempSeq=s2.extractItem(s);
288. tempSeqList.add(tempSeq);
289. }
290. }
292. totalFrequentSeqs.add(seq);
293. recursiveSearchSeqs(seq,tempSeqList);
294. }
295. }
297. printTotalFreSeqs();
298. }
300. /**
301. *按模式类别输出频繁序列模式
302. */
303. privatevoidprintTotalFreSeqs(){
304. System.out.println("序列模式挖掘结果：");
306. ArrayList<Sequence>seqList;
307. HashMap<String,ArrayList<Sequence>>seqMap=newHashMap<>();
308. for(Strings:singleItems){
309. seqList=newArrayList<>();
310. for(Sequenceseq:totalFrequentSeqs){
311. if(seq.getItemSetList().get(0).getItems().get(0).equals(s)){
312. seqList.add(seq);
313. }
314. }
315. seqMap.put(s,seqList);
316. }
318. intcount=0;
319. for(Strings:singleItems){
320. count=0;
321. System.out.println();
322. System.out.println();
324. seqList=(ArrayList<Sequence>)seqMap.get(s);
325. for(SequencetempSeq:seqList){
326. count++;
327. System.out.print("<");
328. for(ItemSetitemSet:tempSeq.getItemSetList()){
329. if(itemSet.getItems().size()>1){
330. System.out.print("(");
331. }
333. for(Stringstr:itemSet.getItems()){
334. System.out.print(str+"");
335. }
337. if(itemSet.getItems().size()>1){
338. System.out.print(")");
339. }
340. }
341. System.out.print(">,");
343. //每5个序列换一行
344. if(count==5){
345. count=0;
346. System.out.println();
347. }
348. }
350. }
351. }
353. }

调用类Client.java:

[java] view plain copy print ?

1. packageDataMining_PrefixSpan;
3. /**
4. *PrefixSpan序列模式挖掘算法
5. *@authorlyq
6. *
7. */
8. publicclassClient{
9. publicstaticvoidmain(String[]agrs){
10. StringfilePath="C:\\Users\\lyq\\Desktop\\icon\\input.txt";
11. //最小支持度阈值率
12. doubleminSupportRate=0.4;
14. PrefixSpanTooltool=newPrefixSpanTool(filePath,minSupportRate);
15. tool.prefixSpanCalculate();
16. }
17. }

输出的结果：

[java] view plain copy print ?

1. 原始序列数据：
2. <(bd)cb(ac)>
3. <(bf)(ce)b(fg)>
4. <(ah)(bf)abf>
5. <(be)(ce)d>
6. <a(bd)bcb(ade)>
7. 序列模式挖掘结果：
10. <a>,<aa>,<ab>,<aba>,<abb>,
13. <b>,<ba>,<bb>,<bba>,<bbc>,
14. <bbf>,<bc>,<bca>,<bcb>,<bcba>,
15. <bcd>,<b(ce)>,<bd>,<(bd)>,<(bd)a>,
16. <(bd)b>,<(bd)ba>,<(bd)bc>,<(bd)c>,<(bd)ca>,
17. <(bd)cb>,<(bd)cba>,<be>,<bf>,<(bf)>,
18. <(bf)b>,<(bf)bf>,<(bf)f>,
20. <c>,<ca>,<cb>,<cba>,<cd>,
21. <(ce)>,
23. <d>,<da>,<db>,<dba>,<dbc>,
24. <dc>,<dca>,<dcb>,<dcba>,
26. <e>,
28. <f>,<fb>,<fbf>,<ff>,

经过比对，与上述表格中的结果完全一致，从结果中可以看出他的递归顺序正是刚刚我所想要的那种。

算法实现时的难点

我在实现这个算法时确实碰到了不少的问题，下面一一列举。

1、Sequence序列在判断或者提取单项和组合项的时候，情况少考虑了，还有考虑到了处理的方式又可能错了。

2、递归的顺序在最早的时候考虑错了，后来对递归的顺序进行了调整。

3、在算法的调试时遇到了，当发现某一项出现问题时，不能够立即调试，因为里面陷入的递归层次实在太深，只能自己先手算此情况下的前缀，后缀序列，然后自己模拟出1个Seq调试，在纠正extract方法时用的比较多。

我对PrefixSpan算法的理解

实现了这个算法之后，再回味这个算法，还是很奇妙的，一个序列，通过从左往右的扫描，通过各个项集的子集，能够组合出许许多多的的序列模式，然后进行挖掘，PrefixSpan通过递归的形式全部找出，而且效率非常高，的确是个很强大的算法。

PrefixSpan算法整体的特点

首先一点，他不会产生候选序列，在产生投影数据库的时候(也就是产生后缀子序列),他的规模是不断减小的。PrefixSpan采用分治法进行序列的挖掘，十分的高效。唯一比较会有影响的开销就是在构造后缀子序列的过程，专业上的名称叫做构造投影数据库的时候。