定义就不解释了，这里只说思路和代码。

以下是我对FPtree算法的个人见解，欢迎指正，共勉。

FPtree是为了解决apriori频繁访问数据库的缺点，它主要有两个过程：1、build-FPtree、2、growth-FPtree

以一个例子来介绍它的思想，事务库初始如下，最小支持度的阈值是2：

a b e 
b d 
b c 
a b d 
a c 
b c 
a c 
a b c e 
a b c 

1、首先我们对出现的每个item进行统计其支持度（相当于频繁1-项目集），并删除小于阈值的item，最后对其进行排序：

b=====>7
c=====>6
a=====>6
e=====>2
d=====>2

2、利用1）的结果对原始数据做两点操作：删除非频繁1-项目集元素和按照支持度重新对每条事务进行排序：

排序整理后的项目集：
b a e 
b d 
b c 
b a d 
c a 
b c 
c a 
b c a e 
b c a 

总的一条就是共前缀！例如bae和bad就可以共ba，这样它们的计数为b2、a2、d1；但是bca和ca就不能共前缀！！！

FP-growth（tree，a）
{
if(tree只包含单个路径){
     对于路径中的所有结点，找到它们组合的所有情况，对于每种情况（B），将a并入到其中，此时每种情况就是一个频繁项目，它的支持度为B中结点的最小支持度，将每个B（含有a的B）加入到频繁项目集中
      }
else{
       if(a(后缀式)!=null){
       将a与分别与此时项头表中的每个元素进行组合，并加入到频繁项目集中，其支持度为项头表中元素的支持度
       }
       
       for each ai 在FP-tree的项表头（倒序） do begin
       {
       （1）产生一个模式B=（ai并a），a为null，则将它视为空字符串
       （2）构造B的条件模式基，然后构造B的条件FP-tree TreeB
       （3）if TreeB != null 
              {
               FP-growth(TreeB,B)
              }
       }
       
    }
}

初看会觉得很复杂难懂，将下面例子看完后，再来看这个伪代码，会有意外收获！

1、第一次调用growth-FPtree的时候，后缀式a为空，于是找到项头表的最后一个元素d，找到它的条件模式基，所谓的条件模式基，就是沿着每个d结点，往上找，直到root结点，其中路径经过的结点组合在一起就为d的一个条件模式基（不含d），这个条件模式基（不含d）的support就是d的support，本例题d的条件模式基为：{(ba,1)(b,1)}

构建d的条件FPtree，这个过程相当于将条件模式基看成一个新的事务库，对其进行build-FPtree过程，先删除非频繁项目集a，只有一个元素b所以就不用排序，得到：

再对其进行growth-FPtree过程（此时的后缀式为元素d）,由于它是单路径的，所以根据伪代码，将单路径仅有的元素b与后缀式组合得到一个频繁项目，（bd）

2、处理表头项的倒数第二个元素e，此时还是属于第一次调用growth-FPtree的时候，后缀式还是空；

找到e的条件模式基：{(ba,1)(bca,1)}

构造条件FPtree：

再对其进行growth-FPtree过程（此时的后缀式为元素d）,由于它是单路径的，所以根据伪代码，将单路径上的所有结点进行组合（b、a、ba）并分别再与后缀式组合得到频繁项目集，{ be ae bae}

3、处理表头项的倒数第三个元素a，此时还是属于第一次调用growth-FPtree的时候，后缀式还是空；

找到a的条件模式基：{(b,2)(c,2)(bc,2)}

构造条件FPtree：

再对其进行growth-FPtree过程（此时的后缀式为元素a）,它不是单路径并且后缀式不为空，根据伪代码，将后缀式a与项表头的每个元素进行组合（ba、ca），并将其加入到频繁项目集中；

此时这部分并没有结束，还得对上项表头中的元素进行build-FPtree过程，

1）找到c的条件模式基{（b,2) }，构建FPtree:

对其进行growth-FPtree，（此时的后缀式为ca），它是单路径且后缀式不为空，根据伪代码，得到组合（bca，2)，将其加入到频繁项目集中；

2）找到b的条件模式基{ },发现它为空，不做处理；

4、…

…

本代码用java编写，输入方式采用的是读文件的形式，本菜鸟编码能力有限，可能繁化了一些操作，（最后我也不想再对代码进行优化了…个人觉得这个算法的编码还是有点难度的！！！肝了我五六个小时，这也足以证明我有多菜了吧哈哈）

package myDataMining;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.*;

public class myFPtree {
//    每个结点的信息，自定义的数据结构
    public static class TreeNode{
        // 节点类别名称
        private String name;
        // 计数数量
        private Integer count;
        // 父亲节点
        private TreeNode parentNode;
        // 孩子节点，可以为多个
        private ArrayList<TreeNode> childNodes=new ArrayList<>();




        private TreeNode left;

        public TreeNode(){

        }

        public TreeNode(String name,int count){
            this.name=name;
            this.count=count;
        }


    }



//定义的一些全局变量
//    记录所有的事务
    public static List<List<String>> record=new ArrayList<List<String>>();
    //    事物总条数
    public static Integer totalT;
//    最小支持数的阈值
    public static double MIN_SUPPORT;
//   记录每个item出现的次数，以便得到orderedRecord
   public static Map<String,Integer> ItemsCount =new HashMap<String,Integer>();
//    排序后的项目集
//  项表头
    public static List<TreeNode> form;
//    记录过程中产生的频繁集
    public static Map<String,Integer> frequentSet=new HashMap<>();
    //


   private static List<List<String>> orderedRecord;



    //从文件夹读数据，每次读一行存储
    public static List<List<String>> getRecord(String url){

        List<List<String>> record = new ArrayList<List<String>>();
        try {
            String encoding = "UTF-8";
            File file = new File(url);
            if (file.isFile() && file.exists()) {
                InputStreamReader read = new InputStreamReader(
                        new FileInputStream(file), encoding);
                BufferedReader bufferedReader = new BufferedReader(read);
                String lineTXT = null;
                int t=0;
                while ((lineTXT = bufferedReader.readLine()) != null) {//读一行文件
                    t++;
                    String[] lineString = lineTXT.split(" ");
                    List<String> lineList = new ArrayList<String>();
                    for (int i = 0; i < lineString.length; i++) {
                        lineList.add(lineString[i]);

                        if(ItemsCount.containsKey(lineString[i])){
                            Integer count = ItemsCount.get(lineString[i]);
                            ItemsCount.put(lineString[i],++count);
                        }
                        else {
                            ItemsCount.put(lineString[i],1);
                        }
                    }
                    record.add(lineList);
                }
                totalT=t;
                read.close();
            } else {
                System.out.println("找不到指定的文件！");
            }
        } catch (Exception e) {
            System.out.println("读取文件内容操作出错");
            e.printStackTrace();
        }
        return record;
    }


    public static void main(String[] args){
//        C:\Users\LUOJUN\Desktop\test
        System.out.println("请输入最小支持度：");
        Scanner scanner = new Scanner(System.in);
        MIN_SUPPORT=scanner.nextDouble();

        System.out.println("请输入待处理的文件地址：");
        String url = scanner.next();
        record = getRecord(url);
        if(record.isEmpty())
        {
            System.out.println("程序结束！！！");
            return;
        }else {
            System.out.println("读取数据成功！！！！！！！！！总共有"+totalT+"条数据");
            for (List<String> stringList : record) {
                for (String s : stringList) {
                    System.out.print(s+" ");
                }
                System.out.println();
            }


            System.out.println("当前最小支持度的阈值为"+MIN_SUPPORT+";现在对小于阈值的item进行处理，结果如下");
            Iterator<Map.Entry<String, Integer>> iterator = ItemsCount.entrySet().iterator();
            while (iterator.hasNext()){
                Map.Entry<String, Integer> next = iterator.next();
                if(next.getValue()<MIN_SUPPORT){
                    iterator.remove();
                }
            }
            for(Map.Entry<String,Integer> entry:ItemsCount.entrySet()){
                System.out.println(entry.getKey()+"===>"+entry.getValue());
            }

//            排序整理后的项目集


            TreeNode root=new TreeNode();
           form= buildFPtree(root,record,ItemsCount);
            System.out.println("下面对出现过的item进行排序：");
            for (TreeNode treeNode : form) {
                System.out.println(treeNode.name+"=====>"+treeNode.count);
            }
            System.out.println("排序整理后的项目集：");
            for (List<String> stringList : orderedRecord) {
                for (String s : stringList) {
                    System.out.print(s+" ");
                }
                System.out.println();
            }


           FPgrowth(root,null,form);
           System.out.print("频繁项目集为：{");
           for(Map.Entry<String,Integer> entry:frequentSet.entrySet()){
               System.out.print(" "+entry.getKey());
           }
           System.out.println("}");
           System.out.println("======================================");


        }
    }

    private static void FPgrowth(TreeNode root, String o,List<TreeNode> form) {
//        如果tree只有一条路径,则将form表头项中的所有元素与o组合加入到频繁项目集中
        if(TreeOnlyOnePath(root)){
            System.out.print("后缀式"+o+"的频繁项目集有：{");
            ArrayList<String> strings = new ArrayList<>();
            String s="";
            for(int i=0;i<form.size();i++){
                s=s+form.get(i).name;
            }
            String s1="";
            strings.add(s1);
            for(int i=0;i<s.length();i++){
                int size = strings.size();
                for(int j=0;j<size;j++){
                    String s2 = strings.get(j);
                    strings.add(s2+s.charAt(i));
                }
            }
           strings.remove(0);
            for (String string : strings) {
                int last = string.length() - 1;
                String c = String.valueOf(string.charAt(last));
                int count=0;
                for (TreeNode treeNode : form) {
                    if(treeNode.name.equals(c)){
                        count=treeNode.count;
                    }
                }
                System.out.print(" "+string+o);
                frequentSet.put(string+o,count);
            }

            System.out.println("}");

            System.out.println("======================================");
        }
//        如果tree不是单路径
        else {
            if(o==null){
//                第一次进入这个方法没有后缀式
                o="";
            }
            else {
//                有后缀式，并将其与form表头项中的元素组合加入到频繁集中
                System.out.print("后缀式"+o+"的频繁项目集有：{");
                for (TreeNode treeNode : form) {
                    frequentSet.put(treeNode.name+o,treeNode.count);
                    System.out.print(" "+treeNode.name+o);
                }
                System.out.println("}");
            }
//            tree有多路径，所以需要继续挖掘，条件模式相当于源数据，基于条件模式要继续建树，直到tree为单路径
                for(int i=form.size()-1;i>=0;i--){
                    TreeNode formNode = form.get(i);
                    TreeNode p=formNode.left;
                    Map<ArrayList<String>,Integer> conditionPatternSet = new HashMap<>();

                    while (p!=null){
                        ArrayList<String> list = new ArrayList<>();

                        TreeNode q=p.parentNode;
                        Stack<String> stack = new Stack<>();
                        while (q.parentNode!=null){
                            stack.push(q.name);
                            q=q.parentNode;
                        }
                        while (!stack.isEmpty()){
                            list.add(stack.pop());
                        }
                        if(list.size()!=0)
                        conditionPatternSet.put(list,p.count);
                        p=p.left;
                    }
                    HashMap<String, Integer> itemcount = new HashMap<String, Integer>();
                    System.out.println("=====================================================");
                    System.out.print("元素"+form.get(i).name+o+"的条件模式基为：{");
                    for(Map.Entry<ArrayList<String>,Integer> entry:conditionPatternSet.entrySet()){
                        ArrayList<String> key = entry.getKey();

                        System.out.print("(");
                        for (String s : key) {
                            if(itemcount.containsKey(s)){
                                Integer integer = itemcount.get(s);
                                itemcount.put(s,integer+entry.getValue());
                            }else {
                                itemcount.put(s, entry.getValue());
                            }
                            System.out.print(s);
                        }
                        System.out.print(","+entry.getValue()+")");
                    }
                    System.out.println("}");

//                    构造条件FPtree
//                    删除小于min——support的item
                    System.out.println("当前最小支持度的阈值为"+MIN_SUPPORT+";现在对小于阈值的item进行处理，结果如下");
                    Iterator<Map.Entry<String, Integer>> iterator = itemcount.entrySet().iterator();
                    while (iterator.hasNext()){
                        Map.Entry<String, Integer> next = iterator.next();
                        if(next.getValue()<MIN_SUPPORT){
                            iterator.remove();
                        }
                    }
                    for(Map.Entry<String,Integer> entry:itemcount.entrySet()){
                        System.out.println(entry.getKey()+"===>"+entry.getValue());
                    }
                    List<List<String>> orderedRecord= new ArrayList<List<String>>();

                    Iterator<Map.Entry<ArrayList<String>, Integer>> iterator1 = conditionPatternSet.entrySet().iterator();
                    while (iterator1.hasNext()){
                        Map.Entry<ArrayList<String>, Integer> next = iterator1.next();
                        Iterator<String> iterator2 = next.getKey().iterator();
                        while (iterator2.hasNext()){
                            String next1 = iterator2.next();
                            if(!itemcount.containsKey(next1)){
                                iterator2.remove();
                            }
                        }

                    }
                    for(Map.Entry<ArrayList<String>,Integer> entry:conditionPatternSet.entrySet()){
                        Integer j = entry.getValue();
                        for(int k=1;k<=j;k++){
                            orderedRecord.add(entry.getKey());
                        }
                    }

                    TreeNode root1=new TreeNode();

                    List<TreeNode> formNodes = buildFPtree(root1, orderedRecord, itemcount);

                    if (formNodes.size()==0){
                        System.out.println("项目"+form.get(i).name+o+"的条件FPtree为空！！");
//                        System.out.println("======================================");
                    }
                    else {
                        FPgrowth(root1,form.get(i).name+o,formNodes);
                    }


                }




        }
    }
//  判断是不是单路经树
    private static boolean TreeOnlyOnePath(TreeNode root) {
        TreeNode p=root;
        while (p!=null){
            if(p.childNodes.size()!=1){
                return false;
            }

            p=p.childNodes.get(0);
            if(p.childNodes.size()==0)
                break;
        }
        return true;
    }
//建FPtree
    private static List<TreeNode> buildFPtree(TreeNode root, List<List<String>> record, Map<String, Integer> itemsCount) {
        ArrayList<TreeNode> curForm = new ArrayList<>();
        for(Map.Entry<String,Integer> entry:itemsCount.entrySet()){
            TreeNode treeNode = new TreeNode();
            treeNode.name=entry.getKey();
            treeNode.count=entry.getValue();
            curForm.add(treeNode);
        }

        for(int i=0;i< curForm.size()-1;i++){
            for(int j=i+1;j<curForm.size();j++){
                if(curForm.get(j).count>=curForm.get(i).count){
                    TreeNode t=curForm.get(j);
                    curForm.set(j,curForm.get(i));
                    curForm.set(i,t);
                }
            }
        }

        List<List<String>> orderedRecord=  getOrderedRecord(record,curForm);
        myFPtree.orderedRecord=orderedRecord;

        for (List<String> strings : orderedRecord) {
                 TreeNode p=root;

                if(root.childNodes.size()==0){

                    for (String string : strings) {
                      TreeNode node=  new TreeNode(string,1);
                        TreeNode formNode= query(curForm,node);
                        formNode.left=node;
                        node.parentNode=p;
                        p.childNodes.add(node);
                        p=node;
                    }

                }

                else {
                    for (String string : strings) {
                       TreeNode a= childNodesHasString(p,string);
                        if(a==null){
                          TreeNode b=  new TreeNode(string,1);
                            TreeNode query = query(curForm, b);

                            if(query.left!=null){
                                while (query.left!=null){
                                    query=query.left;
                                }
                            }
                            query.left=b;
                            b.parentNode=p;
                            p.childNodes.add(b);
                            p=b;

                        }else {
                            Integer count = a.count;
                            a.count=count+1;
                            p=a;
                        }
                    }


                }
            }



        return curForm;

    }
//判断string是否在结点p中的孩子结点中
    private static TreeNode childNodesHasString(TreeNode p, String string) {

        ArrayList<TreeNode> childNodes = p.childNodes;
        for (TreeNode childNode : childNodes) {
            if(childNode.name.equals(string)){
                return childNode;
            }
        }
        return null;
    }
// 返回的是项头表中与node的name相同的结点
    private static TreeNode query(ArrayList<TreeNode> curForm, TreeNode node) {

        TreeNode p=node;
        for (TreeNode treeNode : curForm) {
            if(treeNode.name.equals(node.name)){
                p= treeNode;
            }
        }
        return p;
    }

//将事务根据item的频繁数进行排序
    private static List<List<String>> getOrderedRecord(List<List<String>> record, ArrayList<TreeNode> curForm) {

        List<List<String>> orderedRecord= new ArrayList<List<String>>();
        for (List<String> strings : record) {
            for(int i=0;i<strings.size()-1;i++){
                for(int j=0;j<strings.size()-1-i;j++){
                    if(getFormIndex(curForm,strings.get(j+1))<getFormIndex(curForm,strings.get(j))){
                       String s= strings.get(j);
                       strings.set(j, strings.get(j+1));
                       strings.set(j+1,s);
                    }
                }
            }
        }



        for (List<String> strings : record) {
            ArrayList<String> list = new ArrayList<>();
            for (String string : strings) {
                if(curFormHas(curForm,string)){
                    list.add(string);
                }
            }
            orderedRecord.add(list);
        }
        return orderedRecord;

    }

    private static boolean curFormHas(ArrayList<TreeNode> curForm, String string) {
        for (TreeNode treeNode : curForm) {
            if(treeNode.name.equals(string)){
                return true;
            }
        }
        return false;
    }

    private static int getFormIndex(ArrayList<TreeNode> curForm, String s) {

        for (TreeNode treeNode : curForm) {
            if(treeNode.name.equals(s)){
                return curForm.indexOf(treeNode);
            }
        }
        return 0;

    }


}
//    a b e
//        b d
//        b c
//        a b d
//        a c
//        b c
//        a c
//        a b c e
//        a b c
urForm, String string) {
        for (TreeNode treeNode : curForm) {
            if(treeNode.name.equals(string)){
                return true;
            }
        }
        return false;
    }

    private static int getFormIndex(ArrayList<TreeNode> curForm, String s) {

        for (TreeNode treeNode : curForm) {
            if(treeNode.name.equals(s)){
                return curForm.indexOf(treeNode);
            }
        }
        return 0;

    }


}
//    a b e
//        b d
//        b c
//        a b d
//        a c
//        b c
//        a c
//        a b c e
//        a b c