GSP序列模式分析算法

参考资料：http://blog.csdn.net/zone_programming/article/details/42032309

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

介绍

GSP算法是序列模式挖掘算法的一种，他是一种类Apriori的一种，整个过程与Apriori算法比较类似，不过在细节上会略有不同，在下面的描述中，将会有所描述。GSP在原有的频繁模式定义的概念下，增加了3个的概念。

1、加入时间约束min_gap，max_gap，要求原来的连续变为只要满足在规定的min_gap到max_gap之间即可。

2、加入time_windows_size，只要在windows_size内的item，都可以被认为是同一ItemSet。

3、加入分类标准。

以上3点新的中的第一条特征将会在后面的算法中着重展现。

算法原理

1、根据所输入的序列，找出所有的单项集，即1频繁模式，这里会经过最小支持度阈值的判断。

2、根据1频繁模式进行连接运算，产生2频繁模式，这里会有进行最小阈值的判断。

3、根据2频繁模式连接产生3频繁模式，会经过最小支持度判断和剪枝操作，剪枝操作的原理在于判断他的所有子集是否也全是频繁模式。

4、3频繁模式不断的挖掘知道不能够产生出候选集为止。

连接操作的原理

2个序列，全部变为item列表的形式，如果a序列去掉第1个元素后，b序列去掉最后1个序列，2个序列的item完全一致，则代表可以连接，由b的最后一个元素加入到a中，至于是以独立项集的身份加入还是加入到a中最后1个项集中取决于b中的最后一个元素所属项集是否为单项项集。

时间约束计算

这个是用在支持度计数使用的，GSP算法的支持度计算不是那么简单，比如序列判断<2, <3, 4>>是否在序列<(1,5), 2 , <3, 4>, 2>，这就不能仅仅判断序列中是否只包含2,<3, 4>就行了，还要满足时间间隔约束，这就要把2，和<3,4>的所有出现时间都找出来，然后再里面找出一条满足时间约束的路径就算包含。时间的定义是从左往右起1.2,3...继续，以1个项集为单位，所有2的时间有2个分别为t=2和t=4，然后同理，因为<3,4>在序列中只有1次，所以时间为t=3，所以问题就变为了下面一个数组的问题

2  4

3

从时间数组的上往下，通过对多个时间的组合，找出1条满足时间约束的方案，这里的方案只有2-3,4-3,然后判断时间间隔，如果存在这样的方式，则代表此序列支持所给定序列，支持度值加1,这个算法在程序的实现中是比较复杂的。

算法的代码实现

测试数据输入(格式：事务ID item数 item1 item2.....):

 1 2 1 5
 1 1 2
 1 1 3
 1 1 4
 2 1 1
 2 1 3
 2 1 4
 2 2 3 5
 3 1 1
 3 1 2
 3 1 3
 3 1 4
 3 1 5
 4 1 1
 4 1 3
 4 1 5
 5 1 4
 5 1 5

最后组成的序列为：

<(1,5) 2 3 4>

<1 3 4 (3,5)>

<1 2 3 4 5>

<1 3 5>

<4 5>

也就是说同一序列都是同事务的。下面是关键的类

Sequence.java:

 package DataMining_GSP;

 import java.util.ArrayList;

 /**
  * 序列，每个序列内部包含多组ItemSet项集
  *
  * @author lyq
  *
  */
 public class Sequence implements Comparable<Sequence>, Cloneable {
     // 序列所属事务ID
     private int trsanctionID;
     // 项集列表
     private ArrayList<ItemSet> itemSetList;

     public Sequence(int trsanctionID) {
         this.trsanctionID = trsanctionID;
         this.itemSetList = new ArrayList<>();
     }

     public Sequence() {
         this.itemSetList = new ArrayList<>();
     }

     public int getTrsanctionID() {
         return trsanctionID;
     }

     public void setTrsanctionID(int trsanctionID) {
         this.trsanctionID = trsanctionID;
     }

     public ArrayList<ItemSet> getItemSetList() {
         return itemSetList;
     }

     public void setItemSetList(ArrayList<ItemSet> itemSetList) {
         this.itemSetList = itemSetList;
     }

     /**
      * 取出序列中第一个项集的第一个元素
      *
      * @return
      */
     public Integer getFirstItemSetNum() {
         return this.getItemSetList().get(0).getItems().get(0);
     }

     /**
      * 获取序列中最后一个项集
      *
      * @return
      */
     public ItemSet getLastItemSet() {
         return getItemSetList().get(getItemSetList().size() - 1);
     }

     /**
      * 获取序列中最后一个项集的最后一个一个元素
      *
      * @return
      */
     public Integer getLastItemSetNum() {
         ItemSet lastItemSet = getItemSetList().get(getItemSetList().size() - 1);
         int lastItemNum = lastItemSet.getItems().get(
                 lastItemSet.getItems().size() - 1);

         return lastItemNum;
     }

     /**
      * 判断序列中最后一个项集是否为单一的值
      *
      * @return
      */
     public boolean isLastItemSetSingleNum() {
         ItemSet lastItemSet = getItemSetList().get(getItemSetList().size() - 1);
         int size = lastItemSet.getItems().size();

         return size == 1 ? true : false;
     }

     @Override
     public int compareTo(Sequence o) {
         // TODO Auto-generated method stub
         return this.getFirstItemSetNum().compareTo(o.getFirstItemSetNum());
     }

     @Override
     protected Object clone() throws CloneNotSupportedException {
         // TODO Auto-generated method stub
         return super.clone();
     }

     /**
      * 拷贝一份一模一样的序列
      */
     public Sequence copySeqence(){
         Sequence copySeq = new Sequence();
         for(ItemSet itemSet: this.itemSetList){
             copySeq.getItemSetList().add(new ItemSet(itemSet.copyItems()));
         }

         return copySeq;
     }

     /**
      * 比较2个序列是否相等，需要判断内部的每个项集是否完全一致
      *
      * @param seq
      *            比较的序列对象
      * @return
      */
     public boolean compareIsSame(Sequence seq) {
         boolean result = true;
         ArrayList<ItemSet> itemSetList2 = seq.getItemSetList();
         ItemSet tempItemSet1;
         ItemSet tempItemSet2;

         if (itemSetList2.size() != this.itemSetList.size()) {
             return false;
         }
         for (int i = 0; i < itemSetList2.size(); i++) {
             tempItemSet1 = this.itemSetList.get(i);
             tempItemSet2 = itemSetList2.get(i);

             if (!tempItemSet1.compareIsSame(tempItemSet2)) {
                 // 只要不相等，直接退出函数
                 result = false;
                 break;
             }
         }

         return result;
     }

     /**
      * 生成此序列的所有子序列
      *
      * @return
      */
     public ArrayList<Sequence> createChildSeqs() {
         ArrayList<Sequence> childSeqs = new ArrayList<>();
         ArrayList<Integer> tempItems;
         Sequence tempSeq = null;
         ItemSet tempItemSet;

         for (int i = 0; i < this.itemSetList.size(); i++) {
             tempItemSet = itemSetList.get(i);
             if (tempItemSet.getItems().size() == 1) {
                 tempSeq = this.copySeqence();

                 // 如果只有项集中只有1个元素，则直接移除
                 tempSeq.itemSetList.remove(i);
                 childSeqs.add(tempSeq);
             } else {
                 tempItems = tempItemSet.getItems();
                 for (int j = 0; j < tempItems.size(); j++) {
                     tempSeq = this.copySeqence();

                     // 在拷贝的序列中移除一个数字
                     tempSeq.getItemSetList().get(i).getItems().remove(j);
                     childSeqs.add(tempSeq);
                 }
             }
         }

         return childSeqs;
     }

 }

ItemSet.java:

 package DataMining_GSP;

 import java.util.ArrayList;

 /**
  * 序列中的子项集
  *
  * @author lyq
  *
  */
 public class ItemSet {
     /**
      * 项集中保存的是数字项数组
      */
     private ArrayList<Integer> items;

     public ItemSet(String[] itemStr) {
         items = new ArrayList<>();
         for (String s : itemStr) {
             items.add(Integer.parseInt(s));
         }
     }

     public ItemSet(int[] itemNum) {
         items = new ArrayList<>();
         for (int num : itemNum) {
             items.add(num);
         }
     }

     public ItemSet(ArrayList<Integer> itemNum) {
         this.items = itemNum;
     }

     public ArrayList<Integer> getItems() {
         return items;
     }

     public void setItems(ArrayList<Integer> items) {
         this.items = items;
     }

     /**
      * 判断2个项集是否相等
      *
      * @param itemSet
      *            比较对象
      * @return
      */
     public boolean compareIsSame(ItemSet itemSet) {
         boolean result = true;

         if (this.items.size() != itemSet.items.size()) {
             return false;
         }

         for (int i = 0; i < itemSet.items.size(); i++) {
             if (this.items.get(i) != itemSet.items.get(i)) {
                 // 只要有值不相等，直接算作不相等
                 result = false;
                 break;
             }
         }

         return result;
     }

     /**
      * 拷贝项集中同样的数据一份
      *
      * @return
      */
     public ArrayList<Integer> copyItems() {
         ArrayList<Integer> copyItems = new ArrayList<>();

         for (int num : this.items) {
             copyItems.add(num);
         }

         return copyItems;
     }
 }

GSPTool.java(算法工具类)：

 package DataMining_GSP;

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;

 /**
  * GSP序列模式分析算法
  *
  * @author lyq
  *
  */
 public class GSPTool {
     // 测试数据文件地址
     private String filePath;
     // 最小支持度阈值
     private int minSupportCount;
     // 时间最小间隔
     private int min_gap;
     // 时间最大间隔
     private int max_gap;
     // 原始数据序列
     private ArrayList<Sequence> totalSequences;
     // GSP算法中产生的所有的频繁项集序列
     private ArrayList<Sequence> totalFrequencySeqs;
     // 序列项数字对时间的映射图容器
     private ArrayList<ArrayList<HashMap<Integer, Integer>>> itemNum2Time;

     public GSPTool(String filePath, int minSupportCount, int min_gap,
             int max_gap) {
         this.filePath = filePath;
         this.minSupportCount = minSupportCount;
         this.min_gap = min_gap;
         this.max_gap = max_gap;
         totalFrequencySeqs = new ArrayList<>();
         readDataFile();
     }

     /**
      * 从文件中读取数据
      */
     private void readDataFile() {
         File file = new File(filePath);
         ArrayList<String[]> dataArray = new ArrayList<String[]>();

         try {
             BufferedReader in = new BufferedReader(new FileReader(file));
             String str;
             String[] tempArray;
             while ((str = in.readLine()) != null) {
                 tempArray = str.split(" ");
                 dataArray.add(tempArray);
             }
             in.close();
         } catch (IOException e) {
             e.getStackTrace();
         }

         HashMap<Integer, Sequence> mapSeq = new HashMap<>();
         Sequence seq;
         ItemSet itemSet;
         int tID;
         String[] itemStr;
         for (String[] str : dataArray) {
             tID = Integer.parseInt(str[0]);
             itemStr = new String[Integer.parseInt(str[1])];
             System.arraycopy(str, 2, itemStr, 0, itemStr.length);
             itemSet = new ItemSet(itemStr);

             if (mapSeq.containsKey(tID)) {
                 seq = mapSeq.get(tID);
             } else {
                 seq = new Sequence(tID);
             }
             seq.getItemSetList().add(itemSet);
             mapSeq.put(tID, seq);
         }

         // 将序列图加入到序列List中
         totalSequences = new ArrayList<>();
         for (Map.Entry entry : mapSeq.entrySet()) {
             totalSequences.add((Sequence) entry.getValue());
         }
     }

     /**
      * 生成1频繁项集
      *
      * @return
      */
     private ArrayList<Sequence> generateOneFrequencyItem() {
         int count = 0;
         int currentTransanctionID = 0;
         Sequence tempSeq;
         ItemSet tempItemSet;
         HashMap<Integer, Integer> itemNumMap = new HashMap<>();
         ArrayList<Sequence> seqList = new ArrayList<>();

         for (Sequence seq : totalSequences) {
             for (ItemSet itemSet : seq.getItemSetList()) {
                 for (int num : itemSet.getItems()) {
                     // 如果没有此种类型项，则进行添加操作
                     if (!itemNumMap.containsKey(num)) {
                         itemNumMap.put(num, 1);
                     }
                 }
             }
         }

         boolean isContain = false;
         int number = 0;
         for (Map.Entry entry : itemNumMap.entrySet()) {
             count = 0;
             number = (int) entry.getKey();
             for (Sequence seq : totalSequences) {
                 isContain = false;

                 for (ItemSet itemSet : seq.getItemSetList()) {
                     for (int num : itemSet.getItems()) {
                         if (num == number) {
                             isContain = true;
                             break;
                         }
                     }

                     if(isContain){
                         break;
                     }
                 }

                 if(isContain){
                     count++;
                 }
             }

             itemNumMap.put(number, count);
         }


         for (Map.Entry entry : itemNumMap.entrySet()) {
             count = (int) entry.getValue();
             if (count >= minSupportCount) {
                 tempSeq = new Sequence();
                 tempItemSet = new ItemSet(new int[] { (int) entry.getKey() });

                 tempSeq.getItemSetList().add(tempItemSet);
                 seqList.add(tempSeq);
             }

         }
         // 将序列升序排列
         Collections.sort(seqList);
         // 将频繁1项集加入总频繁项集列表中
         totalFrequencySeqs.addAll(seqList);

         return seqList;
     }

     /**
      * 通过1频繁项集连接产生2频繁项集
      *
      * @param oneSeq
      *            1频繁项集序列
      * @return
      */
     private ArrayList<Sequence> generateTwoFrequencyItem(
             ArrayList<Sequence> oneSeq) {
         Sequence tempSeq;
         ArrayList<Sequence> resultSeq = new ArrayList<>();
         ItemSet tempItemSet;
         int num1;
         int num2;

         // 假如将<a>,<b>2个1频繁项集做连接组合，可以分为<a a>，<a b>，<b a>,<b b>4个序列模式
         // 注意此时的每个序列中包含2个独立项集
         for (int i = 0; i < oneSeq.size(); i++) {
             num1 = oneSeq.get(i).getFirstItemSetNum();
             for (int j = 0; j < oneSeq.size(); j++) {
                 num2 = oneSeq.get(j).getFirstItemSetNum();

                 tempSeq = new Sequence();
                 tempItemSet = new ItemSet(new int[] { num1 });
                 tempSeq.getItemSetList().add(tempItemSet);
                 tempItemSet = new ItemSet(new int[] { num2 });
                 tempSeq.getItemSetList().add(tempItemSet);

                 if (countSupport(tempSeq) >= minSupportCount) {
                     resultSeq.add(tempSeq);
                 }
             }
         }

         // 上面连接还有1种情况是每个序列中只包含有一个项集的情况，此时a,b的划分则是<(a,a)> <(a,b)> <(b,b)>
         for (int i = 0; i < oneSeq.size(); i++) {
             num1 = oneSeq.get(i).getFirstItemSetNum();
             for (int j = i; j < oneSeq.size(); j++) {
                 num2 = oneSeq.get(j).getFirstItemSetNum();

                 tempSeq = new Sequence();
                 tempItemSet = new ItemSet(new int[] { num1, num2 });
                 tempSeq.getItemSetList().add(tempItemSet);

                 if (countSupport(tempSeq) >= minSupportCount) {
                     resultSeq.add(tempSeq);
                 }
             }
         }
         // 同样将2频繁项集加入到总频繁项集中
         totalFrequencySeqs.addAll(resultSeq);

         return resultSeq;
     }

     /**
      * 根据上次的频繁集连接产生新的侯选集
      *
      * @param seqList
      *            上次产生的候选集
      * @return
      */
     private ArrayList<Sequence> generateCandidateItem(
             ArrayList<Sequence> seqList) {
         Sequence tempSeq;
         ArrayList<Integer> tempNumArray;
         ArrayList<Sequence> resultSeq = new ArrayList<>();
         // 序列数字项列表
         ArrayList<ArrayList<Integer>> seqNums = new ArrayList<>();

         for (int i = 0; i < seqList.size(); i++) {
             tempNumArray = new ArrayList<>();
             tempSeq = seqList.get(i);
             for (ItemSet itemSet : tempSeq.getItemSetList()) {
                 tempNumArray.addAll(itemSet.copyItems());
             }
             seqNums.add(tempNumArray);
         }

         ArrayList<Integer> array1;
         ArrayList<Integer> array2;
         // 序列i,j的拷贝
         Sequence seqi = null;
         Sequence seqj = null;
         // 判断是否能够连接，默认能连接
         boolean canConnect = true;
         // 进行连接运算，包括自己与自己连接
         for (int i = 0; i < seqNums.size(); i++) {
             for (int j = 0; j < seqNums.size(); j++) {
                 array1 = (ArrayList<Integer>) seqNums.get(i).clone();
                 array2 = (ArrayList<Integer>) seqNums.get(j).clone();

                 // 将第一个数字组去掉第一个，第二个数字组去掉最后一个，如果剩下的部分相等，则可以连接
                 array1.remove(0);
                 array2.remove(array2.size() - 1);

                 canConnect = true;
                 for (int k = 0; k < array1.size(); k++) {
                     if (array1.get(k) != array2.get(k)) {
                         canConnect = false;
                         break;
                     }
                 }

                 if (canConnect) {
                     seqi = seqList.get(i).copySeqence();
                     seqj = seqList.get(j).copySeqence();

                     int lastItemNum = seqj.getLastItemSetNum();
                     if (seqj.isLastItemSetSingleNum()) {
                         // 如果j序列的最后项集为单一值，则最后一个数字以独立项集加入i序列
                         ItemSet itemSet = new ItemSet(new int[] { lastItemNum });
                         seqi.getItemSetList().add(itemSet);
                     } else {
                         // 如果j序列的最后项集为非单一值，则最后一个数字加入i序列最后一个项集中
                         ItemSet itemSet = seqi.getLastItemSet();
                         itemSet.getItems().add(lastItemNum);
                     }

                     // 判断是否超过最小支持度阈值
                     if (isChildSeqContained(seqi)
                             && countSupport(seqi) >= minSupportCount) {
                         resultSeq.add(seqi);
                     }
                 }
             }
         }

         totalFrequencySeqs.addAll(resultSeq);
         return resultSeq;
     }

     /**
      * 判断此序列的所有子序列是否也是频繁序列
      *
      * @param seq
      *            待比较序列
      * @return
      */
     private boolean isChildSeqContained(Sequence seq) {
         boolean isContained = false;
         ArrayList<Sequence> childSeqs;

         childSeqs = seq.createChildSeqs();
         for (Sequence tempSeq : childSeqs) {
             isContained = false;

             for (Sequence frequencySeq : totalFrequencySeqs) {
                 if (tempSeq.compareIsSame(frequencySeq)) {
                     isContained = true;
                     break;
                 }
             }

             if (!isContained) {
                 break;
             }
         }

         return isContained;
     }

     /**
      * 候选集判断支持度的值
      *
      * @param seq
      *            待判断序列
      * @return
      */
     private int countSupport(Sequence seq) {
         int count = 0;
         int matchNum = 0;
         Sequence tempSeq;
         ItemSet tempItemSet;
         HashMap<Integer, Integer> timeMap;
         ArrayList<ItemSet> itemSetList;
         ArrayList<ArrayList<Integer>> numArray = new ArrayList<>();
         // 每项集对应的时间链表
         ArrayList<ArrayList<Integer>> timeArray = new ArrayList<>();

         for (ItemSet itemSet : seq.getItemSetList()) {
             numArray.add(itemSet.getItems());
         }

         for (int i = 0; i < totalSequences.size(); i++) {
             timeArray = new ArrayList<>();

             for (int s = 0; s < numArray.size(); s++) {
                 ArrayList<Integer> childNum = numArray.get(s);
                 ArrayList<Integer> localTime = new ArrayList<>();
                 tempSeq = totalSequences.get(i);
                 itemSetList = tempSeq.getItemSetList();

                 for (int j = 0; j < itemSetList.size(); j++) {
                     tempItemSet = itemSetList.get(j);
                     matchNum = 0;
                     int t = 0;

                     if (tempItemSet.getItems().size() == childNum.size()) {
                         timeMap = itemNum2Time.get(i).get(j);
                         // 只有当项集长度匹配时才匹配
                         for (int k = 0; k < childNum.size(); k++) {
                             if (timeMap.containsKey(childNum.get(k))) {
                                 matchNum++;
                                 t = timeMap.get(childNum.get(k));
                             }
                         }

                         // 如果完全匹配，则记录时间
                         if (matchNum == childNum.size()) {
                             localTime.add(t);
                         }
                     }

                 }

                 if (localTime.size() > 0) {
                     timeArray.add(localTime);
                 }
             }

             // 判断时间是否满足时间最大最小约束，如果满足，则此条事务包含候选事务
             if (timeArray.size() == numArray.size()
                     && judgeTimeInGap(timeArray)) {
                 count++;
             }
         }

         return count;
     }

     /**
      * 判断事务是否满足时间约束
      *
      * @param timeArray
      *            时间数组，每行代表各项集的在事务中的发生时间链表
      * @return
      */
     private boolean judgeTimeInGap(ArrayList<ArrayList<Integer>> timeArray) {
         boolean result = false;
         int preTime = 0;
         ArrayList<Integer> firstTimes = timeArray.get(0);
         timeArray.remove(0);

         if (timeArray.size() == 0) {
             return false;
         }

         for (int i = 0; i < firstTimes.size(); i++) {
             preTime = firstTimes.get(i);

             if (dfsJudgeTime(preTime, timeArray)) {
                 result = true;
                 break;
             }
         }

         return result;
     }

     /**
      * 深度优先遍历时间，判断是否有符合条件的时间间隔
      *
      * @param preTime
      * @param timeArray
      * @return
      */
     private boolean dfsJudgeTime(int preTime,
             ArrayList<ArrayList<Integer>> timeArray) {
         boolean result = false;
         ArrayList<ArrayList<Integer>> timeArrayClone = (ArrayList<ArrayList<Integer>>) timeArray
                 .clone();
         ArrayList<Integer> firstItemItem = timeArrayClone.get(0);

         for (int i = 0; i < firstItemItem.size(); i++) {
             if (firstItemItem.get(i) - preTime >= min_gap
                     && firstItemItem.get(i) - preTime <= max_gap) {
                 // 如果此2项间隔时间满足时间约束，则继续往下递归
                 preTime = firstItemItem.get(i);
                 timeArrayClone.remove(0);

                 if (timeArrayClone.size() == 0) {
                     return true;
                 } else {
                     result = dfsJudgeTime(preTime, timeArrayClone);
                     if (result) {
                         return true;
                     }
                 }
             }
         }

         return result;
     }

     /**
      * 初始化序列项到时间的序列图，为了后面的时间约束计算
      */
     private void initItemNumToTimeMap() {
         Sequence seq;
         itemNum2Time = new ArrayList<>();
         HashMap<Integer, Integer> tempMap;
         ArrayList<HashMap<Integer, Integer>> tempMapList;

         for (int i = 0; i < totalSequences.size(); i++) {
             seq = totalSequences.get(i);
             tempMapList = new ArrayList<>();

             for (int j = 0; j < seq.getItemSetList().size(); j++) {
                 ItemSet itemSet = seq.getItemSetList().get(j);
                 tempMap = new HashMap<>();
                 for (int itemNum : itemSet.getItems()) {
                     tempMap.put(itemNum, j + 1);
                 }

                 tempMapList.add(tempMap);
             }

             itemNum2Time.add(tempMapList);
         }
     }

     /**
      * 进行GSP算法计算
      */
     public void gspCalculate() {
         ArrayList<Sequence> oneSeq;
         ArrayList<Sequence> twoSeq;
         ArrayList<Sequence> candidateSeq;

         initItemNumToTimeMap();
         oneSeq = generateOneFrequencyItem();
         twoSeq = generateTwoFrequencyItem(oneSeq);
         candidateSeq = twoSeq;

         // 不断连接生产候选集，直到没有产生出侯选集
         for (;;) {
             candidateSeq = generateCandidateItem(candidateSeq);

             if (candidateSeq.size() == 0) {
                 break;
             }
         }

         outputSeqence(totalFrequencySeqs);

     }

     /**
      * 输出序列列表信息
      *
      * @param outputSeqList
      *            待输出序列列表
      */
     private void outputSeqence(ArrayList<Sequence> outputSeqList) {
         for (Sequence seq : outputSeqList) {
             System.out.print("<");
             for (ItemSet itemSet : seq.getItemSetList()) {
                 System.out.print("(");
                 for (int num : itemSet.getItems()) {
                     System.out.print(num + ",");
                 }
                 System.out.print("), ");
             }
             System.out.println(">");
         }
     }

 }

调用类Client.java:

 package DataMining_GSP;

 /**
  * GSP序列模式分析算法
  * @author lyq
  *
  */
 public class Client {
     public static void main(String[] args){
         String filePath = "C:\\Users\\lyq\\Desktop\\icon\\testInput.txt";
         //最小支持度阈值
         int minSupportCount = 2;
         //时间最小间隔
         int min_gap = 1;
         //施加最大间隔
         int max_gap = 5;

         GSPTool tool = new GSPTool(filePath, minSupportCount, min_gap, max_gap);
         tool.gspCalculate();
     }
 }

算法的输出(挖掘出的所有频繁模式)：

 <(1,), >
 <(2,), >
 <(3,), >
 <(4,), >
 <(5,), >
 <(1,), (3,), >
 <(1,), (4,), >
 <(1,), (5,), >
 <(2,), (3,), >
 <(2,), (4,), >
 <(3,), (4,), >
 <(3,), (5,), >
 <(4,), (5,), >
 <(1,), (3,), (4,), >
 <(1,), (3,), (5,), >
 <(2,), (3,), (4,), >

算法实现的难点

1、算法花费了几天的时间，难点首先在于对算法原理本身的理解，网上对于此算法的资料特别少，而且不同的人所表达的意思 都有少许的不同，讲的也不是很详细，于是就通过阅读别人的代码理解GSP算法的原理，我的代码实现也是参考了参考资料的C语言的实现。

2、在实现时间约束的支持度计数统计的时候，调试了一段时间，做时间统计容易出错，因为层级实在太多容易搞晕。

3、还有1个是Sequence和ItemSet的拷贝时的引用问题，在产生新的序列时一定要深拷贝1个否则导致同一引用会把原数据给改掉的。

GSP算法和Apriori算法的比较

我是都实现过了GSP算法和Apriori算法的，后者是被称为关联规则挖掘算法，偏向于挖掘关联规则的，2个算法在连接的操作上有不一样的地方，还有在数据的构成方式上，Apriori的数据会简单一点，都是单项单项构成的，而且在做支持度统计的时候只需判断存在与否即可。不需要考虑时间约束。Apriori算法给定K项集，连接到K-1项集算法就停止了，而GSP算法是直到不能够产生候选集为止。