FP—Growth算法

FP_growth算法是韩家炜老师在2000年提出的关联分析算法，该算法和Apriori算法最大的不同有两点：

第一，不产生候选集，第二，只需要两次遍历数据库，大大提高了效率，用31646条测试记录，最小支持度是2%，

用Apriori算法要半个小时但是用FP_growth算法只要6分钟就可以了，效率非常明显。

它的核心是FP_tree，一种树型数据结构，特点是尽量把相同元素用一个节点表示，这样就大大减少了空间，和birch算法有类似的思想。还是以如下数据为例。

每一行表示一条交易，共有9行，既9笔交易，左边表示交易ID，右边表示商品名称。最小支持度是22%，那么每件商品至少要出现9*22%=2次才算频繁。第一次扫描数据库，统计每件商品出现的次数，按次数对各个商品递减排序，有：。然后第二次扫描数据库，在每条交易中按此种顺序给商品排序，如果有某个商品出现的次数小于阈值2，则删除该商品，有：

剩下的就是构造FP_tree了，这是核心，树的每个节点的结构体如下：

//FP-tree的存储结构
typedef struct CSNode{
 //商品编号
 int item;
 //次数
 int count;
 //父节点，孩子节点，兄弟节点
 CSNode *parent,*firstchild,*nextsibling;
 //相同商品的前驱，后继节点，方便将相同商品的节点连接起来,根节点的直接孩子节点的这两个指针都是空
 CSNode *pre,*next;
}*CSTree;
其中item,*firstchild,*nextsibling是树这个结构体常用的属性。count记录商品item出现的次数，*parent是为了方便从叶子节点逆向访问根节点而设置的。*pre,*next的注释已经很清楚了。构造树的原则是：将每条记录看做一个从根节点到叶子节点的路径，如果某个商品在节点中已经存在了，则对应count计数器加1，相当于所有的前缀都要加1,如果不存在则在该条记录的后面商品开辟一条新的路径。下面一条一条记录演示怎么构造FP_tree。

    第三次访问数据库，构造FP_tree。第一条记录：I2,I1,I5，有：

父节点没有表示出来，根节点是空节点。2:1表示商品2出现了1次，其他表示类推。左边的数组按照商品顺序递减排列，保存了各个商品的当前指针，目的是为了在后面找到相同的后缀，将相同的商品用单项箭头虚线连起来，实际是双向链表链接的，并且将此时的节点商品1和节点商品5保存为商品1和商品5的当前指针，而对于商品2，商品3，商品4的当前指针还在左边的数组中保存。注意根节点的直接孩子不用连起来，后面会讲理由。第二条记录：I2,I4，有：

该记录和第一条记录共用前缀I2,所以商品2的次数要加1，而商品4则作为商品2的一个新孩子节点，这里没有把兄弟节点画出来。并且左边商品4要指向该节点，此时商品4的当前指针指向节点商品4。第三条记录：I2,I3,类似，结果是：

第四条记录：I2,I1,I4有：

当添加完商品4后，商品4的当前指针要指向新的节点商品4，此时两条红色的虚线就把以商品4为后缀的节点连起来了。第5条记录：I1,I3,有：

商品1由于和根节点的所有直接子孩子（这里只有商品2这个子孩子）不同，因此要另外开辟一条路径。商品3的当前指针要指向新的节点商品3，如图中的黄色虚线所指，到这里体现了构造FP_tree的一般性了。再把剩下的记录都加进来，最终的FP_tree是：

这颗FP_tree最大程度的把相同的商品放在用同一个节点保存，最大限度的节省了空间。剩下的工作就是挖掘这颗FP_tree了。

    挖掘的目的是找出FP_tree的各个路径中相同的集合，有两中方式，方式一，从根节点朝叶子节点顺着遍历树，方式二，从叶子节点朝根节点逆着遍历树。想想方式一挺麻烦的，幸亏我们设置了*parent指针，通过它就可以很方便的用方式二。我们从商品出现次数由少到多的顺序开始遍历树，先从商品5开始，由于有*pre,*next指针分方便将所有以商品5做为叶子节点的路径全找出来，然后再根据*parent指针找到父节点，根节点是空不用找。以I5做元素的条件模式基是：{(I2 I1:1),(I2 I1 I3:1)}。后面的1表示出现商品I2,I1,I5同时出现的次数。现在解释为什么：根节点的直接孩子不用*pre,*next指针连起来，因为假如连起来的话，那么以它为后缀时，将没有前缀，也就是说它的频繁项集是1，这在大多数情况下没意义。由它构造出条件FP_tree，注意由于开始按照商品名称排序了，那么条件模式基中的每一项也会按照这种方式排序。如果条件模式基中某项A是另外一项B的子集那么在算B时，要将A出现的次数加上，实现这个功能最简单明了的方法就是一一匹配，假如条件模式基共有N项，则时间复杂度是N的平方，若先按照条件模式基的长度递增排序得到：{(I2 I1:1),(I2 I1 I3:1)}，排序的时间复杂度是N*log(N),那么只有可能是长度短的项是长度长的项的子集，此时总匹配次数是：N-1 + N-2 + ,,, + 1 = N*(N-1)/2,和前面的排序时间加起来是：N*log(N) + N*(N-1)/2当N大于时4时，该值小于N的平方。在实际中N一般会大于4。最终我们得到以I5作为后缀的频繁项集是：{I2 I5:2},{I1 I5:2},{I2 I1 I5:2}他们出现的次数都大于等于最小支持度。类似可以得到其它后缀的频繁项集。

    FP_growth算法不产生候选序列，并且只需要3次遍历数据库，对比Apriori算法而言有了很大的改进。其实想想这也符合历史发展的规律，Apriori在1993年才提出来的，那是数据挖掘才刚起步，而到2000年时，已经有了一定的发展，FP_growth是站在Apriori的肩膀上发明的，这种现象具有普遍性。

 

 

FP—growth代码实现部分

主程序部分

package DataMining_FPTree;
/**
 * FPTree频繁模式树算法
 * 一个使用的这个算法的用例是输入一个单词或者单词的一部分，搜索引擎就会自动 补全查询词项，通过查看互联网上的用词来找出经常在一块出现的词对（使用Aporior算法也是找出经常出现的词对，这两种方法都是无监督学习），这需要一种发现频繁集的方法
 * @author clj
 *
 */
public class Client {
    public static void main(String[] args){
        //这里使用的是输入文件的绝对路径
        String filePath="E:\\code\\data mining\\DataMining_FPTree\\src\\DataMining_FPTree\\testInput.txt";
        //最小支持度阈值
        int minSupportCount = 2;
        //构造函数
        FPTreeTool tool = new FPTreeTool(filePath, minSupportCount);
        //调用构建树
        tool.startBuildingTree();
    }
}

树节点的数据结构

package DataMining_FPTree;

import java.util.ArrayList;

/**
 * FP树节点
 * 这里使用Comparable的原因是因为每个项集要进行排序
 * 按照节点的count来排序
 * @author clj
 * 
 */
public class TreeNode implements Comparable<TreeNode>, Cloneable{
    // 节点类别名称
    private String name;
    // 计数数量
    private Integer count;
    // 父亲节点，这个节点的用法是根据给定叶子节点上溯到整棵树，这时就需要指向父节点
    private TreeNode parentNode;
    // 孩子节点，可以为多个
    private ArrayList<TreeNode> childNodes;
    
    public TreeNode(String name, int count){
        this.name = name;
        this.count = count;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getCount() {
        return count;
    }

    public void setCount(Integer count) {
        this.count = count;
    }

    public TreeNode getParentNode() {
        return parentNode;
    }

    public void setParentNode(TreeNode parentNode) {
        this.parentNode = parentNode;
    }

    public ArrayList<TreeNode> getChildNodes() {//孩子节点可能不止一个，所以需要用list来保存
        return childNodes;
    }

    public void setChildNodes(ArrayList<TreeNode> childNodes) {
        this.childNodes = childNodes;
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {//如果想重写父类的方法，比如toString()方法的话，在方法前面加上@Override  系统可以帮你检查方法的正确性，
        // TODO Auto-generated method stub
        //因为对象内部有引用，需要采用深拷贝，这里就相当于是一个深度优先搜索,这里的clone相当于没有用
        //System.out.println("The name="+this.getName());
        
        TreeNode node = (TreeNode)super.clone(); 
        if(this.getParentNode() != null){
            node.setParentNode((TreeNode) this.getParentNode().clone());
        }
        
        if(this.getChildNodes() != null){
            node.setChildNodes((ArrayList<TreeNode>) this.getChildNodes().clone());
        }
        
        return node;
    }
    
}

程序的主要部分FPTreeTool

package DataMining_FPTree;

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.Iterator;
import java.util.Map;
import java.util.Map.Entry;

/**
 * FPTree算法工具类
 * 与Apriori算法不同的是FP树需要将非频繁项移除并且重排序
 * @author clj
 * 
 */
public class FPTreeTool {
    // 输入数据文件位置
    private String filePath;
    // 最小支持度阈值
    private int minSupportCount;
    // 所有事物ID记录
    private ArrayList<String[]> totalGoodsID;
    // 各个ID的统计数目映射表项，计数用于排序使用，用于项集
    private HashMap<String, Integer> itemCountMap;
    //后面的成员方法中并没有重新定义成员变量，所以成员函数中可以改变的成员变量的值

    public FPTreeTool(String filePath, int minSupportCount) {
        this.filePath = filePath;
        this.minSupportCount = minSupportCount;
        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();
        }

        String[] temp;
        int count = 0;
        itemCountMap = new HashMap<>();//之所以使用会使用hashMap的形式是因为后面会更改key所对应的value的值，时间复杂度小
        totalGoodsID = new ArrayList<>();//totalGoodsId只需要将其保存在矩阵中
        for (String[] a : dataArray) {
            temp = new String[a.length - 1];
            System.arraycopy(a, 1, temp, 0, a.length - 1);//和Apriori算法一样第一个保存的是第几笔记录
            totalGoodsID.add(temp);
            for (String s : temp) {
                if (!itemCountMap.containsKey(s)) {
                    count = 1;
                } else {
                    count = ((int) itemCountMap.get(s));
                    // 支持度计数加1
                    count++;
                }
                // 更新表项，如果有key s，则直接更新，否则创建
                itemCountMap.put(s, count);
            }
        }
        System.out.println("name="+itemCountMap.keySet()+" count="+itemCountMap.values());
        
    }

    /**
     * 根据事务记录构造FP树
     * 当suffixPattern不为空的时候，建立的就是条件FP树
     * surffixPatter是后缀模式
     */
    private void buildFPTree(ArrayList<String> suffixPattern,
            ArrayList<ArrayList<TreeNode>> transctionList) {
    
        
        // 设置一个空根节点
        TreeNode rootNode = new TreeNode(null, 0);
        int count = 0;
        // 节点是否存在
        boolean isExist = false;
        ArrayList<TreeNode> childNodes;
        ArrayList<TreeNode> pathList;
        // 相同类型节点链表，用于构造的新的FP树
        HashMap<String, ArrayList<TreeNode>> linkedNode = new HashMap<>();//每个节点的LinkNode
        HashMap<String, Integer> countNode = new HashMap<>();
        // 根据事务记录，一步步构建FP树，逐个读入事务记录，并把每个事务映射到FP树中的一条路径中
        for (ArrayList<TreeNode> array : transctionList) {
            TreeNode searchedNode;//TreeNode节点中每个项集中应该是只有一个元素
            pathList = new ArrayList<>();//在构建的时候，将读入的每个项集添加到一条已经存在的路径中
            /*
            System.out.print("array=");
            for(int i=0;i<array.size();i++)
                System.out.print("\t"+array.get(i).getName());
            System.out.println();
            */
            for (TreeNode node : array) {//array保存的是FP中的一条路径
                pathList.add(node);//pathList开始为空，在事务中读到一个节点就把它放到pathList中
                //System.out.println("正在处理的节点node="+node.getName()+" count="+node.getCount());
                //System.out.println("before keySets="+countNode.keySet()+"count="+countNode.values());
                nodeCounted(node, countNode);//countNode是一个HashMap类型，初始时为一个空的HashMap，在读事务过程中依次进行修改
                //System.out.println("after keySets="+countNode.keySet()+"count="+countNode.values());
                /*System.out.print("pathList=");
                for(int i=0;i<pathList.size();i++)
                    System.out.print("\t"+pathList.get(i).getName());
                System.out.println();
                */
                searchedNode = searchNode(rootNode, pathList);//这里只是查找，不会影响count的变化
                childNodes = searchedNode.getChildNodes();

                if (childNodes == null) {//如果正好找到路径中的结尾，则直接加入到结尾
                    //System.out.println("找到了对应的叶节点，在叶节点下存储");
                    childNodes = new ArrayList<>();
                    childNodes.add(node);
                    searchedNode.setChildNodes(childNodes);
                    node.setParentNode(searchedNode);
                    nodeAddToLinkedList(node, linkedNode);
                } else {
                    isExist = false;
                    for (TreeNode node2 : childNodes) {
                        // 如果找到名称相同，则更新支持度计数
                        //System.out.println("##############");
                        if (node.getName().equals(node2.getName())) {
                            //System.out.println("在父节点下找到了对应的节点");
                            count = node2.getCount() + node.getCount();
                            node2.setCount(count);
                            // 标识已找到节点位置
                            isExist = true;
                            break;
                        }
                    }

                    if (!isExist) {
                        // 如果没有找到，需添加子节点
                        //System.out.println("&没有在父节点下找到了对应的节点");
                        childNodes.add(node);
                        node.setParentNode(searchedNode);
                        nodeAddToLinkedList(node, linkedNode);
                    }
                }
                //System.out.println("countNode.key="+countNode.keySet()+"   value="+countNode.values());
                
                /*Iterator<Entry<String, ArrayList<TreeNode>>> it = linkedNode.entrySet().iterator();
                while( it.hasNext())
                {
                    Map.Entry<String, ArrayList<TreeNode>> entry = it.next();
                    String key = entry.getKey();
                    ArrayList<TreeNode> values=(ArrayList<TreeNode>)entry.getValue();
                    for(TreeNode value:values)
                    {
                        System.out.print(" linkedNode.name="+value.getName()+"\tLinkedNode.count="+value.getCount());
                    }
                    System.out.println();
                    //TreeNode tempNode= entry.getValue().get(i);
                }*/
                

            }
        }

        // 如果FP树已经是单条路径，则输出此时的频繁模式
        if(suffixPattern!=null)
        {
            System.out.println("suffixPattern.size="+suffixPattern.size());
            for(int i=0;i<suffixPattern.size();i++)
                System.out.print(suffixPattern.get(i)+"\t ");
            System.out.println();
        }
        else 
            System.out.println("suffixPattern.size=0");
        if (isSinglePath(rootNode)) {
            System.out.println("issinglePath-------");
            printFrequentPattern(suffixPattern, rootNode);
            
        } else {
            ArrayList<ArrayList<TreeNode>> tList;
            ArrayList<String> sPattern;
            if (suffixPattern == null) {
                sPattern = new ArrayList<>();
            } else {
                // 进行一个拷贝，避免互相引用的影响
                sPattern = (ArrayList<String>) suffixPattern.clone();
            }

            // 利用节点链表构造新的事务
            for (Map.Entry entry : countNode.entrySet()) {
                // 添加到后缀模式中
                sPattern.add((String) entry.getKey());
                System.out.println("entry.key="+entry.getKey()+"\tentry.value="+entry.getValue());
                
                //获取到了条件模式机，作为新的事务
                tList = getTransactionList((String) entry.getKey(), linkedNode);
                
                System.out.print("[后缀模式]：{");
                for(String s: sPattern){
                    System.out.print(s + ", ");
                }
                System.out.print("}, 此时的条件模式基：");
                for(ArrayList<TreeNode> tnList: tList){
                    System.out.print("{");
                    for(TreeNode n: tnList){
                        System.out.print(n.getName() + ", ");
                    }
                    System.out.print("}, ");
                }
                System.out.println();
                // 递归构造FP树
                buildFPTree(sPattern, tList);
                // 再次移除此项，构造不同的后缀模式，防止对后面造成干扰
                sPattern.remove((String) entry.getKey());
            }
        }
    }

    /**
     * 将节点加入到同类型节点的链表中
     * 
     * @param node
     *            待加入节点
     * @param linkedList
     *            链表图
     */
    private void nodeAddToLinkedList(TreeNode node,
            HashMap<String, ArrayList<TreeNode>> linkedList) {
        String name = node.getName();
        ArrayList<TreeNode> list;

        if (linkedList.containsKey(name)) {
            list = linkedList.get(name);
            // 将node添加到此队列末尾
            list.add(node);
        } else {
            list = new ArrayList<>();
            list.add(node);
            linkedList.put(name, list);
        }
    }

    /**
     * 根据链表构造出新的事务,根据name，得到以name为尾的各记录
     * 
     * @param name
     *            节点名称
     * @param linkedList
     *            链表
     * @return
     */
    private ArrayList<ArrayList<TreeNode>> getTransactionList(String name,
            HashMap<String, ArrayList<TreeNode>> linkedList) {
        ArrayList<ArrayList<TreeNode>> tList = new ArrayList<>();
        ArrayList<TreeNode> targetNode = linkedList.get(name);
        ArrayList<TreeNode> singleTansaction;
        TreeNode temp;
        System.out.println("#getTransaction中name="+name);
        for (TreeNode node : targetNode) {
            singleTansaction = new ArrayList<>();

            temp = node;
            while (temp.getParentNode().getName() != null) {
                System.out.println("temp.name="+temp.getName()+"\tcount="+temp.getCount());
                temp = temp.getParentNode();
                
                singleTansaction.add(new TreeNode(temp.getName(), 1));
            }
            System.out.println("temp.name="+temp.getName()+"\tcount="+temp.getCount());
            System.out.println("singleTansaction=");
            for(int i=0;i<singleTansaction.size();i++)
            {
                System.out.println("("+singleTansaction.get(i).getName()+","+singleTansaction.get(i).getCount()+")");
            }
            System.out.println();
            // 按照支持度计数得反转一下
            Collections.reverse(singleTansaction);
            

            for (TreeNode node2 : singleTansaction) {
                // 支持度计数调成与模式后缀一样
                node2.setCount(node.getCount());
            }
            System.out.println("##singleTansaction=");
            for(int i=0;i<singleTansaction.size();i++)
            {
                System.out.println("("+singleTansaction.get(i).getName()+","+singleTansaction.get(i).getCount()+")");
            }
            System.out.println();

            if (singleTansaction.size() > 0) {
                tList.add(singleTansaction);
            }
        }

        return tList;
    }

    /**
     * 节点计数
     * 
     * @param node
     *            待加入节点
     * @param nodeCount
     *            计数映射图
     */
    private void nodeCounted(TreeNode node, HashMap<String, Integer> nodeCount) {
        int count = 0;
        String name = node.getName();

        if (nodeCount.containsKey(name)) {
            count = nodeCount.get(name);
            count++;
        } else {
            count = 1;
        }

        nodeCount.put(name, count);
    }

    /**
     * 显示决策树
     * 
     * @param node
     *            待显示的节点
     * @param blankNum
     *            行空格符，用于显示树型结构
     */
    private void showFPTree(TreeNode node, int blankNum) {
        System.out.println("￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥显示FPTree");
        for (int i = 0; i < blankNum; i++) {
            System.out.print("\t");
        }
        System.out.print("--");
        System.out.print("--");

        if (node.getChildNodes() == null) {//叶子节点
            System.out.print("[");
            System.out.print("I" + node.getName() + ":" + node.getCount());
            System.out.print("]");
        } else {
            // 递归显示子节点
             System.out.print("【" + node.getName() + "】");
            for (TreeNode childNode : node.getChildNodes()) {
                showFPTree(childNode, 2 * blankNum);
            }
        }

    }

    /**
     * 待插入节点的抵达位置节点，从根节点开始向下寻找待插入节点的位置，返回待插入节点的父节点
     * 
     * @param root
     * @param list
     * @return
     */
    private TreeNode searchNode(TreeNode node, ArrayList<TreeNode> list) {
        ArrayList<TreeNode> pathList = new ArrayList<>();
        TreeNode tempNode = null;
        TreeNode firstNode = list.get(0);
        boolean isExist = false;
        // 重新转一遍，避免出现同一引用
        for (TreeNode node2 : list) {
            pathList.add(node2);
        }
        //System.out.println("待插入的节点：name="+node.getName()+" count="+node.getCount());
        /*for(int i=0;i<list.size();i++)
            System.out.print("\t("+list.get(i).getName()+","+list.get(i).getCount()+")");
        System.out.println();*/
        // 如果没有孩子节点，则直接返回，在此节点下添加子节点，查找已构建树中的叶子节点
        if (node.getChildNodes() == null) {
            //System.out.println("此节点为叶子节点，为返回的节点，node.name="+node.getName()+" count="+node.getCount());
            return node;
        }

        for (TreeNode n : node.getChildNodes()) {
            if (n.getName().equals(firstNode.getName()) && list.size() == 1) {//list中只有一个元素，即路径中的第一个元素
                tempNode = node;
                isExist = true;
                //System.out.println("第一个元素恰好为要查找的节点，且节点长度为1");
                break;
            } else if (n.getName().equals(firstNode.getName())) {
                // 还没有找到最后的位置，继续找，在查找的过程中时是正好匹配，从路径中消除
                //System.out.println("#第一个元素恰好为要查找的节点，且节点长度不为1");
                pathList.remove(firstNode);
                tempNode = searchNode(n, pathList);//使用递归的形式去查询子节点
                //System.out.println("￥￥￥返回节点：tempNode.name="+tempNode.getName()+" count="+tempNode.getCount());
                return tempNode;
            }
        }

        // 如果没有找到，则新添加到孩子节点中
        if (!isExist) {
            //System.out.println("没有找到");
            tempNode = node;
        }
        //System.out.println("@@@@返回节点：node.name="+tempNode.getName()+" count="+tempNode.getCount());
        return tempNode;
    }

    /**
     * 判断目前构造的FP树是否是单条路径的
     * 
     * @param rootNode
     *            当前FP树的根节点
     * @return
     */
    private boolean isSinglePath(TreeNode rootNode) {
        // 默认是单条路径
        boolean isSinglePath = true;
        ArrayList<TreeNode> childList;
        TreeNode node;
        node = rootNode;
        //是使用循环而不是递归判断是否是单条路径
        while (node.getChildNodes() != null) {
            childList = node.getChildNodes();
            if (childList.size() == 1) {
                node = childList.get(0);
            } else {
                isSinglePath = false;
                break;
            }
        }

        return isSinglePath;
    }

    /**
     * 开始构建FP树
     */
    public void startBuildingTree() {
        ArrayList<TreeNode> singleTransaction;//单条事务
        ArrayList<ArrayList<TreeNode>> transactionList = new ArrayList<>();//事务总链
        TreeNode tempNode;
        int count = 0;

        for (String[] idArray : totalGoodsID) {
            singleTransaction = new ArrayList<>();
            for (String id : idArray) {
                count = itemCountMap.get(id);
                tempNode = new TreeNode(id, count);
                singleTransaction.add(tempNode);
            }
            
            // 根据支持度数的多少进行排序
            Collections.sort(singleTransaction);
            
            /*System.out.println("singleTansaction as following:");
            for(int i=0;i<singleTransaction.size();i++)
                System.out.print("("+singleTransaction.get(i).getName()+","+singleTransaction.get(i).getCount()+")");
            System.out.println();*/
            
            for (TreeNode node : singleTransaction) {
                // 支持度计数重新归为1,将事务路径节点的count设置为1
                node.setCount(1);
            }
            /*System.out.println("singleTansaction");
            for(int i=0;i<singleTransaction.size();i++)
                System.out.print("***("+singleTransaction.get(i).getName()+","+singleTransaction.get(i).getCount()+")");
            System.out.println();*/
            transactionList.add(singleTransaction);
        }
        for(int i=0;i<transactionList.size();i++)
        {
            ArrayList<TreeNode> singleTransaction1=new ArrayList<>();
            singleTransaction1=transactionList.get(i);
            for(int j=0;j<singleTransaction1.size();j++)
            {
                System.out.print("("+singleTransaction1.get(j).getName()+","+singleTransaction1.get(j).getCount()+")");
            }
            System.out.println();
                
        }
        buildFPTree(null, transactionList);
    }

    /**
     * 输出此单条路径下的频繁模式
     * 
     * @param suffixPattern
     *            后缀模式
     * @param rootNode
     *            单条路径FP树根节点
     */
    private void printFrequentPattern(ArrayList<String> suffixPattern,
            TreeNode rootNode) {
        ArrayList<String> idArray = new ArrayList<>();
        TreeNode temp;
        temp = rootNode;
        // 用于输出组合模式
        int length = 0;
        int num = 0;
        int[] binaryArray;

        while (temp.getChildNodes() != null) {
            temp = temp.getChildNodes().get(0);

            // 筛选支持度系数大于最小阈值的值，P(A)>P(AB),若P(A)<阈值，则删除这个节点即不添加到里面
            if (temp.getCount() >= minSupportCount) {
                idArray.add(temp.getName());
            }
        }

        length = idArray.size();
        num = (int) Math.pow(2, length);
        for (int i = 0; i < num; i++) {
            binaryArray = new int[length];
            numToBinaryArray(binaryArray, i);

            // 如果后缀模式只有1个，不能输出自身
            if (suffixPattern.size() == 1 && i == 0) {
                continue;
            }

            System.out.print("频繁模式：{【后缀模式：");
            // 先输出固有的后缀模式
            if (suffixPattern.size() > 1
                    || (suffixPattern.size() == 1 && idArray.size() > 0)) {
                for (String s : suffixPattern) {
                    System.out.print(s + ", ");
                }
            }
            System.out.print("】");
            // 输出路径上的组合模式
            for (int j = 0; j < length; j++) {
                if (binaryArray[j] == 1) {
                    System.out.print(idArray.get(j) + ", ");
                }
            }
            System.out.println("}");
        }
    }

    /**
     * 数字转为二进制形式
     * 
     * @param binaryArray
     *            转化后的二进制数组形式
     * @param num
     *            待转化数字
     */
    private void numToBinaryArray(int[] binaryArray, int num) {
        int index = 0;
        while (num != 0) {
            binaryArray[index] = num % 2;
            index++;
            num /= 2;
        }
    }

}

readDataFile从文件中读取数据，

buildFPTree(ArrayList<String> suffixPattern,ArrayList<ArrayList<TreeNode>> transctionList)构建FP树（包括FP条件树），当suffixpatter不为空的时候构建的就是FP条件树，

nodeAddToLinkedList(TreeNode node,HashMap<String, ArrayList<TreeNode>> linkedList)，和邻接表类似，某个Node在树中出现的位置保存在linkedList中

private ArrayList<ArrayList<TreeNode>> getTransactionList(String name,HashMap<String, ArrayList<TreeNode>> linkedList）得到还有name节点的交易记录

nodeCounted(TreeNode node, HashMap<String, Integer> nodeCount)因为最后交易记录是以节点的计数多少进行排序的，这一个记录node在所有记录中出现的次数，同一条事务其实是没有先后顺序的，为了把树尽可能的减小才这样进行排序的

showFPTree(TreeNode node, int blankNum) 展示树

private TreeNode searchNode(TreeNode node, ArrayList<TreeNode> list) 要插入的节点在树中应该插入到哪个节点的下面呢，这里返回的是待插入节点的父节点

printFrequentPattern(ArrayList<String> suffixPattern,TreeNode rootNode)输出单条路径下的频繁模式，

 常见的频繁项集挖掘算法有两类，一类是Apriori算法，另一类是FPGrowth。Apriori通过不断的构造候选集、筛选候选集挖掘出频繁项集，需要多次扫描原始数据，当原始数据较大时，磁盘I/O次数太多，效率比较低下。FPGrowth算法则只需扫描原始数据两遍，通过FP-tree数据结构对原始数据进行压缩，效率较高。

也许有人会问?如果这个数据库足够大,以至于构造的FP树大到无法完全保存在内存中,这该如何是好.这的确是个问题. Han Jiawei在论文中也给出了一种思路,就是通过将原来的大的数据库分区成几个小的数据库(这种小的数据库称之为投射数据库),对这几个小的数据库分别进行FP Growth算法.
还是拿上面的例子来说事,我们把包含p的所有数据库记录都单独存成一个数据库,我们称之为p-投射数据库,类似的m,b,a,c,f我们都可以生成相应的投射数据库,这些投射数据库构成的FP树相对而言大小就小得多,完全可以放在内存里.
在现代数据挖掘任务中,数据量越来越大,因此并行化的需求越来越大,上面提出的问题也越来越迫切.下一篇博客,博主将分析一下,FP Growth如何在MapReduce的框架下并行化.
[1]Mining Frequent Patterns  without Candidate Gen