FpTree

fpGrowth

输入：

?

1 2 3 4 5 6 7 8 9

牛奶,鸡蛋,面包,薯片 鸡蛋,爆米花,薯片,啤酒 鸡蛋,面包,薯片 牛奶,鸡蛋,面包,爆米花,薯片,啤酒 牛奶,面包,啤酒 鸡蛋,面包,啤酒 牛奶,面包,薯片 牛奶,鸡蛋,面包,黄油,薯片 牛奶,鸡蛋,黄油,薯片

输出：

?

1 2 3 4 5 6 7 8 9 10 11 12 13

啤酒,鸡蛋     3 啤酒,面包     3 牛奶,鸡蛋     4 牛奶,鸡蛋,面包     3 牛奶,鸡蛋,面包,薯片     3 牛奶,鸡蛋,薯片     4 牛奶,面包     5 牛奶,面包,薯片     4 牛奶,薯片     5 鸡蛋,面包     5 鸡蛋,面包,薯片     4 鸡蛋,薯片     6 面包,薯片     5

节点定义：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

import  org.apache.commons.lang.StringUtils;   public  class  TreeNode {            private  TreeNode parent;      private  String name;      private  int  count;      private  Set<TreeNode> children;            public  TreeNode(TreeNode parent,String name, int  count){          this .count = count;          this .parent = parent;          this .name = name;      }            public  TreeNode(String name, int  count){          this .name = name;          this .count = count;      }      /**       * 当前节点计数+i       * @param i       */      public  void  incrementCount( int  i){          this .count = count + i;      }      /**       * 父节点是否包含子节点包含则返回，否则返回null       * @param key       * @return       */      public  TreeNode findChild(String key){          if ( this .children ==  null ){              return  null ;          }          for (TreeNode child: this .children){              if (StringUtils.equals(child.name,key)){                  return  child;              }          }          return  null ;      }      /**       * 给父节点增加一个子节点       * @param child       * @return       */      public  TreeNode addChild(TreeNode child){          if ( this .children ==  null ){              this .children =  new  HashSet<TreeNode>();          }          this .children.add(child);          return  child;      }      public  boolean  isEmpty(){          return  this .children== null  ||  this .children.size()== 0 ;      }            public  TreeNode getParent() {          return  parent;      }      public  void  setParent(TreeNode parent) {          this .parent = parent;      }      public  String getName() {          return  name;      }      public  void  setName(String name) {          this .name = name;      }      public  int  getCount() {          return  count;      }      public  void  setCount( int  count) {          this .count = count;      }        public  Set<TreeNode> getChildren() {          return  children;      }        public  void  setChildren(Set<TreeNode> children) {          this .children = children;      }       }

挖掘算法：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167

import  org.apache.commons.io.FileUtils; import  org.apache.commons.lang.StringUtils;   public  class  FpTree {            private  static  int  support =  3 ;            public  static  void  main(String[] args)  throws  IOException{          //从文件中读取事物数据集          String file =  "D:\\R\\aprior.txt" ;          Iterator<String> lineIte = FileUtils.lineIterator( new  File(file));          List<List<String>> transactions =  new  ArrayList<List<String>>();          while (lineIte.hasNext()){              String line = lineIte.next();              if (StringUtils.isNotEmpty(line)){                  String[] subjects = line.split( "," );                  List<String> list =  new  ArrayList<String>(Arrays.asList(subjects));                  transactions.add(list);              }          }          //初始一个频繁模式集          List<String> frequences =  new  LinkedList<String>();          //开始递归          digTree(transactions,frequences);      }            public  static  void  digTree(List<List<String>> transactions,              List<String> frequences){          //扫描事物数据集，排序          final  Map<String,Integer> sortedMap = scanAndSort(transactions);          //没有数据是支持最小支持度了，可以停止了          if (sortedMap.size() ==  0 ){              return ;          }          Map<String,List<TreeNode>> index =  new  HashMap<String,List<TreeNode>>();          TreeNode root = buildTree(transactions,index,sortedMap);            //否则开始从排序最低的项开始 抽出条件模式基，递归挖掘          List<String> headTable =  new  ArrayList<String>(sortedMap.keySet());          Collections.sort(headTable, new  Comparator<String>(){              @Override              public  int  compare(String o1, String o2) {                  int  i = sortedMap.get(o2)-sortedMap.get(o1);                   return  i !=  0  ? i : o1.compareTo(o2);              }});          //从项头表最后一项开始挖掘          for ( int  i=headTable.size()- 1 ;i>= 0 ;i--){              String subject = headTable.get(i);              List<List<String>> frequentModeBases = extract(index.get(subject),root);                            LinkedList<String> nextFrequences =  new  LinkedList<String>(frequences);              nextFrequences.add(subject);              if (nextFrequences.size()> 1 ){                  System.out.println(StringUtils.join(nextFrequences, "," )+ "\t" +sortedMap.get(subject));              }                            digTree(frequentModeBases,nextFrequences);                        }      }            /**       * 挖掘一个项上面的频繁模式基       * @param list       * @param root       * @return       */      public  static  List<List<String>> extract(List<TreeNode> list,TreeNode root){          List<List<String>> returnList =  new  ArrayList<List<String>>();          for (TreeNode node:list){              TreeNode parent = node.getParent();              if (parent.getCount() != - 1 ){                  ArrayList<String> tranc =  new  ArrayList<String>();                  while (parent.getCount() != - 1 ){                      tranc.add(parent.getName());                      parent = parent.getParent();                  }                  for ( int  i= 0 ;i<node.getCount();i++){                      returnList.add(tranc);                  }              }          }          return  returnList;      }            /**       * 构建pf树       * @param file       * @param index       * @param sortedMap       * @return       * @throws IOException       */      public  static  TreeNode buildTree(List<List<String>> transactions,              Map<String,List<TreeNode>> index,              final  Map<String,Integer> sortedMap){          TreeNode root =  new  TreeNode( null , "root" ,- 1 );          for (List<String> subjects:transactions){              Iterator<String> ite = subjects.iterator();              while (ite.hasNext()){                  String subject = ite.next();                  if (!sortedMap.containsKey(subject)){                      ite.remove();                  }              }              Collections.sort(subjects, new  Comparator<String>(){                  @Override                  public  int  compare(String o1, String o2) {                      int  i = sortedMap.get(o2)-sortedMap.get(o1);                       return  i !=  0  ? i : o1.compareTo(o2);                  }});                            TreeNode current = root;              for ( int  i= 0 ;i<subjects.size();i++){                  String subject = subjects.get(i);                  TreeNode next = current.findChild(subject);                  if (next ==  null ){                      TreeNode newNode =  new  TreeNode(current,subject, 1 );                      current.addChild(newNode);                      current = newNode;                      List<TreeNode> thisIndex = index.get(subject);                      if (thisIndex ==  null ){                          thisIndex =  new  ArrayList<TreeNode>();                          index.put(subject, thisIndex);                      }                      thisIndex.add(newNode);                  } else {                      next.incrementCount( 1 );                      current = next;                  }              }          }          return  root;      }            /**       * 扫描排序       * @param file       * @return       * @throws IOException       */      public  static  Map<String,Integer> scanAndSort(List<List<String>> transactions){          Map<String,Integer> map =  new  HashMap<String,Integer>();          //空的就不扫了          if (transactions.size()== 0 ){              return  map;          }          for (List<String> basket:transactions){              for (String subject:basket){                  Integer count = map.get(subject);                  if  (count ==  null ) {                      map.put(subject,  1 );                  }  else  {                      map.put(subject, count +  1 );                  }              }          }          Iterator<Entry<String,Integer>> ite = map.entrySet().iterator();          while (ite.hasNext()){              Entry<String,Integer> entry = ite.next();              if (entry.getValue() < support){                  ite.remove();              }          }          return  map;      } }