FP-Tree算法详细过程(Java实现)

public class MyFrequentItem {

    //每项中含有的元素
    private String array;
    //该项的支持度计数
    private int support;
    //该项的长度,即第几项集
    private int arrayLength;
    public MyFrequentItem(String array,int support) {
        this.array=array;
        this.support=support;
        arrayLength=array.length();
    }
    public String getArray() {
        return array;
    }
    public void setArray(String array) {
        this.array = array;
    }
    public int getSupport() {
        return support;
    }
    public void setSupport(int support) {
        this.support = support;
    }
    public int getArrayLength() {
        return arrayLength;
    }
    public void setArrayLength(int arrayLength) {
        this.arrayLength = arrayLength;
    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
/**
 * 
 * @author 石献衡
 *
 */
class FP_Node{//树
    String item;
    int supportCount;
    ArrayList<FP_Node> childNode;
    FP_Node parent;
    public FP_Node(String item,int supportCount,FP_Node parent) {
        this.item=item;
        this.supportCount=supportCount;
        this.parent = parent;
        childNode = new ArrayList<FP_Node>();
    }
}
class LinkedListNode{//链表,同一条链表存储的TP_Node节点的item相同
    FP_Node node;
    LinkedListNode next;
    public LinkedListNode(FP_Node node) {
        this.node=node;
        next=null;
    }
}
public class FP_tree {
    //文件位置
    private String filePath;
    //存储从文件中读取的数据
    private String[][] datas;
    //Integer代表频繁项集的项数,String表示频繁项集各项组成的字符串
    private HashMap<Integer, HashMap<String,MyFrequentItem>> myFrequentItems;
    //单项出现的次数,用来排序
    HashMap<String, Integer> signalCount;
    //最小支持度计数
    private int minSupportCount;
    //最小置信度
    private double minConf;
    //记录的总条数
    private int allDataCount;
    //强规则
    ArrayList<String> strongRules;
    //弱规则
    ArrayList<String> weakRules;
    private MyFrequentItem frequentItem;;
    public FP_tree(String filePath,int minSupportCount) {
        this.minSupportCount = minSupportCount;
        this.filePath = filePath;
        strongRules = new ArrayList<String>();
        weakRules = new ArrayList<String>();
        myFrequentItems = new HashMap<Integer, HashMap<String,MyFrequentItem>>();
        //读取数据
        readFile();
    }
    /**
     * .读取文件中的数据储存到datas
     */
    private void readFile() {
        ArrayList<String[]> list = new ArrayList<String[]>();
        try {
            String string;
            FileReader in = new FileReader(new File(filePath));
            BufferedReader reader = new BufferedReader(in);
            while((string=reader.readLine())!=null) {
                list.add(string.substring(3).split(" "));
            }
            allDataCount = list.size();
            datas = new String[allDataCount][];
            list.toArray(datas);
            reader.close();in.close();
            list.clear();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    public void startTool(double minConf){
        this.minConf = minConf;
        //扫描并且排序
        scanAndSort();
        //初始化myFrequentItems
        for(int i=1;i<=signalCount.size();i++) {
            myFrequentItems.put(i, new HashMap<String, MyFrequentItem>());
        }
        HashMap<String, Integer> originList = new HashMap<String, Integer>();
        //将datas的每条记录转换成一条排序好的字符串和它的支持度的形式
        //如记录{2,1,5}转换成215和1,就如条件模式基以及其支持度计数
        String s;
        for(String[] strs : datas) {
            s = "";
            for (String string : strs) {
                s+=string;
            }
            if(originList.containsKey(s))
                originList.put(s,originList.get(s)+1);
            else
                originList.put(s,1);
        }
        //构造TP树,同时构造链表以及找出所有频繁项
        fp_Growth(originList, signalCount, "",Integer.MAX_VALUE);
        int n = signalCount.size();
        HashMap<String, MyFrequentItem> map = new HashMap<String, MyFrequentItem>();
        String string;
        //输出各频繁项集的频繁项,包括它们的支持度计数
        for(int i=1;i<=n;i++) {
            map = myFrequentItems.get(i);
            System.out.println(i+"-项频繁项集为:");
            for (MyFrequentItem myFrequentItem : map.values()) {
                System.out.print("{");
                string = myFrequentItem.getArray();
                for(int j=0;j<myFrequentItem.getArrayLength();j++) {
                    System.out.print(string.charAt(j)+",");
                }
                System.out.print("(支持度计数:"+myFrequentItem.getSupport()+")} ");
            }
            System.out.println();
        }
        //计算k-频繁项集中各频繁项的置信度
        int k=3;
        if(myFrequentItems.get(k).size()!=0) {
            for (MyFrequentItem frequentItem : myFrequentItems.get(k).values()) {
                relevance(frequentItem);
            }
        }
    }
    /**
     * .计算该最大频繁项集与其子项集的关联性
     * @param index 频繁集中的第index个
     * @param k 项频繁集
     */
    private void relevance(MyFrequentItem myFrequentItem2) {
        //该项的支持度
        int support = myFrequentItem2.getSupport();
        //该频繁项的元素拼接成的字符串
        String nowFrequentString = myFrequentItem2.getArray();
        //找出所有子项集
        childRelevance(nowFrequentString.toCharArray(), 0, "", "", support);
        System.out.println();
        for(String weakRule : weakRules) {
            System.out.println(weakRule);
        }
        for(String strongRule : strongRules) {
            System.out.println(strongRule);
        }
        //输出之后清空
        weakRules.clear();
        strongRules.clear();
    }
    /**
     * .找出所有子项集
     * @param child
     * @param k
     * @param childString 为子项集拼接的字符串
     * @param otherString除子项集以外的拼接的字符串
     * @param support
     */
    private void childRelevance(char[] child,int k,String childString,String otherString,int support) {
        if(child.length==k) {
            //空串和其本身不计算
            if(childString.length()==k||childString.length()==0) return;
            //计算置信度
            calculateRelevance(childString, otherString, support);
        }else {
            childRelevance(child, k+1, childString, otherString+child[k], support);//该字符不要
            childRelevance(child, k+1, childString+child[k], otherString, support);//该字符要
        }
    }
    /**
     * .计算置信度
     * @param childString
     * @param otherString
     * @param support
     */
    private void calculateRelevance(String childString,String otherString,int support) {
        String rule="";
        //获取子频繁项childString的支持度计数
        int childSupport = myFrequentItems.get(childString.length()).get(childString).getSupport();
        double conf = (double)support/(double)childSupport;
        rule+="{";
        for(int m=0;m<childString.length();m++)rule+=(childString.charAt(m)+",");
        rule+="}-->{";
        for(int m=0;m<otherString.length();m++) {
            rule+=(otherString.charAt(m)+",");
        }
        rule+=("},confindence(置信度):"+support+"/"+childSupport+"="+conf);
        if(conf<minConf) {
            rule+=("由于此规则置信度未达到最小置信度的要求，不是强规则");
            weakRules.add(rule);
        }else {
            rule+=("为强规则");
            strongRules.add(rule);
        }
    }
    /**
     * .构建树并找出所有频繁项
     * @param originList 每条路径和该路径的支持度计数
     * @param originCount originList中每个字符的支持度计数
     * @param suffix 后缀
     */
    private void fp_Growth(HashMap<String, Integer> originList,HashMap<String, Integer>originCount,String suffix,int suffixSupport) {
        FP_Node root = new FP_Node(null, 0, null);//条件FP-Tree的根节点
        //表头项
        ArrayList<LinkedListNode> headListNode = new ArrayList<LinkedListNode>();
        //构建树,并检查是否为单路径树
        if(treeGrowth(suffix,root, originList, originCount, headListNode)) {//如果是单路径树,直接进行递归出所有子频繁项
                String string = "";
                while(root.childNode.size()!=0) {
                    root = root.childNode.get(0);
                    string+=root.item;
                }
                //递归找出所有频繁项
                findFrequentItem(0, "", string.toCharArray(), suffixSupport, suffix,originCount);
            
        }else {
            //不是单路径树,从最后一个表头项的最后一个往上找条件模式基
            findConditional(headListNode, originCount, suffix);
        }
    }
    private boolean treeGrowth(String suffix,FP_Node root,HashMap<String, Integer> originList,HashMap<String, Integer>originCount,ArrayList<LinkedListNode> headListNode) {
        //链表的当前节点
        HashMap<String, LinkedListNode> nowNode = new HashMap<String, LinkedListNode>();
        //表示是否找到该字符所在的节点,有则true,否则false并创一个新的节点
        boolean flag;
        //用来记录树是否为单路径
        boolean isSingle = true;
        FP_Node treeHead;
        LinkedListNode listNode;
        String[] strings;
        int support;
        for (String originString : originList.keySet()) {
            //获取该条件模式基的支持度计数
            support = originList.get(originString);
            strings = originString.split("");
            treeHead = root;
            for(int i=0;i<strings.length; i++) {
                //小于最小支持度计数的不加入树中
                if(originCount.get(strings[i])<minSupportCount)continue;
                flag = false;
                for(FP_Node node : treeHead.childNode) {
                    if(strings[i].equals(node.item)) {
                        flag = true;
                        node.supportCount+=support;
                        treeHead = node;
                        break;
                    }
                }
                if(!flag) {//创建新的树节点,同时创建新的链表节点
                    for(int j=i;j<strings.length;j++) {
                        //小于最小支持度计数的不加入树中
                        if(originCount.get(strings[j])<minSupportCount)continue;
                        //创建新的树节点
                        FP_Node node = new FP_Node(strings[j], support,treeHead);
                        if(nowNode.containsKey(strings[j])) {//构建链表
                            listNode = new LinkedListNode(node);
                            nowNode.get(strings[j]).next = listNode;
                            nowNode.put(strings[j], listNode);
                        }else {//构建链表
                            listNode = new LinkedListNode(node);
                            headListNode.add(listNode);
                            nowNode.put(strings[j], listNode);
                        }
                        //构建树
                        treeHead.childNode.add(node);
                        treeHead = node;
                    }
                    break;
                }
            }
        }
        while(root.childNode.size()!=0) {//判断是否为单路径
            if(root.childNode.size()==1) {
                root = root.childNode.get(0);
            }else {
                isSingle = false;
                break;
            }
        }
        if(isSingle) return true;
        Collections.sort(headListNode,new Comparator<LinkedListNode>() {//将链表的头节点按出现的总次数的降序排列
            @Override
            public int compare(LinkedListNode o1, LinkedListNode o2) {
                int p = originCount.get(o2.node.item)-originCount.get(o1.node.item);
                if(p==0)//如果支持度计数相等,按字典序排序
                    return o1.node.item.compareTo(o2.node.item);
                else
                    return p;
            }
        });
        return isSingle;
    }
    /**
     * .找出各项的条件模式基,从headNode后面遍历链表的每个节点,
     * .从每个节点中node开始向树的上方遍历,直到根节点停止
     */
    private void findConditional(ArrayList<LinkedListNode> hNode,HashMap<String, Integer> originSupport,String suffix) {
        //当前链表节点
        LinkedListNode nowListNode;
        //当前树节点
        FP_Node nowTreeNode;
        //条件模式基
        HashMap<String, Integer> originList;
        //所有条件模式基中各个事务出现的次数,方便条件FP-Tree在构造的时候剪枝
        HashMap<String, Integer> originCount;
        String ori;
        String item;
        String suf;
        for(int i=hNode.size()-1;i>=0;i--) {
            //获取链表头节点
            nowListNode = hNode.get(i);
            item = nowListNode.node.item;
            suf = item+suffix;
            //树中的单项支持度计数必定大于或等于最小支持度计数(构建树的完成的剪枝),所以将该项加其后缀加入频繁项集
            myFrequentItems.get(suf.length()).put(suf, new MyFrequentItem(suf, originSupport.get(item)));
            originList = new HashMap<String, Integer>();
            originCount = new HashMap<String, Integer>();
            int min;
            while(nowListNode!=null) {
                //从链表保存的树节点的父节点开始向上遍历
                nowTreeNode = nowListNode.node.parent;
                //获取该节点的支持度计数
                min = nowListNode.node.supportCount;
                //用来保存该条件模式基
                ori = "";
                while(nowTreeNode!=null&&nowTreeNode.item!=null) {
                    if(originCount.containsKey(nowTreeNode.item)) {
                        //如果条件模式基有如21和2这样两条及以上的有共同元素的,支持度计数叠加
                        originCount.put(nowTreeNode.item, originCount.get(nowTreeNode.item)+min);
                    }else {
                        originCount.put(nowTreeNode.item, min);
                    }
                    //保存条件模式基,按树的上面向下的顺序保存
                    ori=nowTreeNode.item+ori;
                    nowTreeNode = nowTreeNode.parent;
                }
                if(ori!="")
                    originList.put(ori, min);
                nowListNode = nowListNode.next;
            }
            if(originList.size()!=0) {//条件模式基不为空
                if(originList.size()==1) {//只有一条,直接递归其所有子项集
                    for (String modeBasis : originList.keySet()) {
                        findFrequentItem(0, "", modeBasis.toCharArray(), originList.get(modeBasis), suf,null);
                    }
                }else {
                    //构建条件FP-Tree
                    fp_Growth(originList, originCount,suf,originSupport.get(item));
                }
            }
        }
    }
    /**
     * 
     * @param j 当前指向的modeBasis中的位置
     * @param child 当前子项
     * @param modeBasis 条件模式基中各个字符或单路径树各个节点组成的字符串
     * @param support 该子项的所有单项中最小的支持度计数
     * @param suffix 后缀,子项加上后缀即为新的频繁项
     * @param originCount 单路径树各个节点的支持度计数
     */
    private void findFrequentItem(int j,String child,char[] modeBasis,int support,String suffix,HashMap<String, Integer> originCount) {
        if(j==modeBasis.length) {
            if(child.length()!=0) {//子项不为空
                child=child+suffix;
                frequentItem = new MyFrequentItem(child, support);
                myFrequentItems.get(child.length()).put(child, frequentItem);
            }
        }else {
            int p = support;
            //originCount为null时,代表为条件模式基,条件模式基中各项支持度计数相等
            if(originCount!=null)
                p =originCount.get(String.valueOf(modeBasis[j]));
            findFrequentItem(j+1, child+modeBasis[j],  modeBasis,support<p?support:p,suffix,originCount);//要该字符
            findFrequentItem(j+1, child,  modeBasis,support,suffix,originCount);//不要该字符
        }
    }
    /**
     * .扫描两遍数据,第一遍得出各个事物出现的总次数
     * .第二遍将每条记录中的事务根据出现的总次数进行排序
     */
    private void scanAndSort() {

        //储存单项的总次数
        signalCount = new HashMap<String, Integer>();
        String c;
        for (String[] string : datas) {//第一遍扫描,储存每个字符出现的次数
            for(int i=0;i<string.length;i++) {
                c = string[i];
                if(signalCount.containsKey(c)) {
                    signalCount.put(c, signalCount.get(c)+1);
                }else {
                    signalCount.put(c, 1);
                }
            }
        }
        for (String[] string : datas) {//第二遍扫描,按每个字符出现的总次数的降序进行排序
            Arrays.sort(string,new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    int p = signalCount.get(o2)-signalCount.get(o1);
                    if(p==0)//如果出现的次数相等,按字典序排序
                        return o1.compareTo(o2);
                    else
                        return p;
                }
            });
        }
    }
    
}

public class MyClient {

    public static void main(String[] args) {
        String filePath = "src/apriori/testInput.txt";
        FP_tree tp_tree = new FP_tree(filePath, 2);
        tp_tree.startTool(0.7);
    }
}