您所在位置： &
&nbsp&&nbsp&nbsp&&nbsp
DMStar组基于AprioriFPGrowth及Eclat算法的频繁模式挖掘project答辩V5.0.ppt24页
本文档一共被下载：
次 ,您可全文免费在线阅读后下载本文档。
文档加载中...广告还剩秒
需要金币：150 &&
DMStar组基于AprioriFPGrowth及Eclat算法的频繁模式挖掘project答辩V5.0.ppt
你可能关注的文档：
··········
··········
* * * * * 谢谢大家！ * 基于Apriori、FP-Growth及Eclat算法的频繁模式挖掘 DMStar 小组 杨
柳 杨华峰 宋旋婷 任智红 梁志溢 贺冠文
主要内容 Apriori算法 FP-Growth算法 Eclat算法
2 3 4 频繁模式挖掘实现概述 1 算法对比评价
6 2 频繁模式挖掘实现概述 实现了Apriori、FP-Growth及Eclat三种频繁模式挖掘算法
对Mushroom、Accidents、 T10I4D100K 三个数据集做频繁模式挖掘实验，设定不同的阈值，对比不同算法挖掘频繁模式的时间 Apriori算法描述 Apriori 算法特点 1、k-1项集连接规律：若有两个k-1项集，每个项集保证有序，如果两个k-1项集的前k-2个项相同，而最后一个项不同，则证明它们是可连接的，可连接生成k项集。 2、反单调性。如果一个项集是频繁的，那么它的所有子集都是频繁的。即若一个项集的子集不是频繁项集，则该项集肯定也不是频繁项集。 Apriori算法流程 1. 扫描数据库，生成候选1项集和频繁1项集。 2. 从2项集开始循环，由频繁k-1项集生成频繁频繁k项集。 2.1? 频繁k-1项集两两组合，判定是否可以连接，若能则连接生成k项集。 2.2? 对k项集中的每个项集检测其子集是否频繁，舍弃掉子集不是频繁项集即
不在频繁k-1项集中的项集。 2.3? 扫描数据库，计算2.3步中过滤后的k项集的支持度，舍弃掉支持度小于阈值的项集，生成频繁k项集。 3.? 若当前k项集中只有一个项集时循环结束。 Apriori主要函数说明 Map Set , Integer
genNextKItem Map Set , Integer
由频繁K-1项集生成频繁K项集
boolean isNeedCut Map Set , Integer
preMap, Set
由于单调性，必须保证k项集的所有k-1项子集都是频繁的，否则就该剪切该k项集
getSubSets Set
获取k项集set的所有k-1项子集
private Map Set , Integer
Map Set , Integer
allKItem 遍历事物数据库
正在加载中，请稍后... 上传我的文档
 下载
 收藏
该文档贡献者很忙，什么也没留下。
 下载此文档
正在努力加载中...
一种基于MapReduce的并行FPgrowth算法
下载积分：1200
内容提示：一种基于MapReduce的并行FPgrowth算法
文档格式：PDF|
浏览次数：14|
上传日期： 11:19:57|
文档星级：
该用户还上传了这些文档
一种基于MapReduce的并行FPgrowth算法
官方公共微信当前位置： →
→ Mahout:2-&PFPGrowth分布式频繁模式挖掘&ParallelFrequentPatternMining&
Mahout:2-&PFPGrowth分布式频繁模式挖掘&ParallelFrequentPatternMining&
& 作者及来源： ForA - 博客园 &
&收藏到→_→：
摘要: Mahout：2-&PFPGrowth | 分布式频繁模式挖掘 &Parallel Frequent Pattern Mining&
"Mahout:2-&PFPGrowth分布式频繁模式挖掘&ParallelFrequentPatternMining&"：：
参考官网，分析源码
1. 网页给出了如何pfp-growth的过程&https://cwiki.apache.org/confluence/display/mahout/parallel+frequent+pattern+mining&但是易发现将其代码复制过去不能运行。原因有：
　　1.1 相应包没有加进去，加的必备包有：mahout，hadoop，hbase。运行过程中会缺什么包，这是找到相应包加进去即可，这是一个折磨人的过程，因为不知道需要的类是包含在哪个包里面，但是一般都有启发式寻找思路。首先确定是在mahout，还是在hadoop下找？然后打开可能的包看下是否包含需要的类。例如本项目中用到了mahout-collections-*.jar找了很久才如何，还有hbase的包！
& & & 1.2 复制过来的代码可能不是针对当前版本的mahout。这就需要根据当前版本的mahout下找源代码的函数是怎么定义，实例又是如何调用包中类（函数）
2. 注重看源码。特别是pfp-growth的源码 org.apache.mahout.fpm.pfpgrowth.fpgrowthdriver.java的运行pfp&growth例子
pfpgrowth实例实现
main代码：
package com.import java.io.import java.io.import java.nio.charset.import java.util. import java.util.import java.util. import org.apache.hadoop.conf.import org.apache.hadoop.fs.import org.apache.hadoop.fs.import org.apache.hadoop.io.import org.apache.hadoop.io. import org.mon. import org.mon. import org.apache.mahout.fpm.pfpgrowth.convertors.import org.apache.mahout.fpm.pfpgrowth.convertors.sequencimport org.apache.mahout.fpm.pfpgrowth.convertors.string.s
import org.apache.mahout.fpm.pfpgrowth.convertors.string.import org.apache.mahout.fpm.pfpgrowth.fpgrowth.
import org.apache.mahout.math.map.oimport org.mon.public class pfpgrowth {
public static void main(string[] args) throws ioexception {
set&string& features = new hashset&string&();
string input = "/usr/hadoop/testdata/pfp.txt";
int minsupport = 3;
int maxheapsize = 50;//top-k
string pattern = " \"[ ,\\t]*[,|\\t][ ,\\t]*\" ";
charset encoding = charset.forname("utf-8");
fpgrowth&string& fp = new fpgrowth&string&();
string output = "output.txt";
path path = new path(output);
configuration conf = new configuration();
filesystem fs = filesystem.get(conf);
sequencefile.writer writer = new sequencefile.writer(fs, conf, path, text.class, topkstringpatterns.class);
fp.generatetopkfrequentpatterns(
new stringrecorditerator(new filelineiterable(new file(input), encoding, false), pattern),
fp.generateflist(
new stringrecorditerator(new filelineiterable(new file(input), encoding, false), pattern),
minsupport),
minsupport,
maxheapsize,
new stringoutputconverter(new sequencefileoutputcollector&text,topkstringpatterns&(writer)),
new contextstatusupdater(null));
writer.close();
list&pair&string,topkstringpatterns&& frequentpatterns = fpgrowth.readfrequentpattern(fs, conf, path);
for (pair&string,topkstringpatterns& entry : frequentpatterns) {
//system.out.print(entry.getfirst()+"-"); // the frequent patterns meet minsupport
system.out.println(entry.getsecond()); // the frequent patterns meet minsupport and support
system.out.print("\nthe end! ");
网址：http://fimi.ua.ac.be/data/&下t10i4d100k&(.gz)数据
运行结果(run on hadoop)：
2011-8-6 9:39:22 org.slf4j.impl.jclloggeradapter info信息: mining ftree tree for all patterns with 3642011-8-6 9:39:22 org.slf4j.impl.jclloggeradapter info信息: found 1 patterns with least support 82011-8-6 9:39:22 org.slf4j.impl.jclloggeradapter info信息: mining ftree tree for all patterns with 3632011-8-6 9:39:22 org.slf4j.impl.jclloggeradapter info信息: found 1 patterns with ......信息: found 1 patterns with least support 592011-8-6 9:39:29 org.slf4j.impl.jclloggeradapter info信息: mining ftree tree for all patterns with 02011-8-6 9:39:29 org.slf4j.impl.jclloggeradapter info信息: found 1 patterns with least support 592011-8-6 9:39:29 org.slf4j.impl.jclloggeradapter info信息: mining ftree tree for all patterns with 02011-8-6 9:39:29 org.slf4j.impl.jclloggeradapter info信息: found 1 patterns with least support 652011-8-6 9:39:29 org.slf4j.impl.jclloggeradapter info信息: tree cache: first level: cache hits=3962 cache misses=489559([97 707 755 918 938 ],3)([95 181 295 758 ],3)([95 145 266 401 797 833 ],3)([94 217 272 620 ],3)([93 517 789 825 ],3) ...([28 145 157 274 346 735 742 809 ],59)([1 66 314 470 523 823 874 884 980 ],65)the end!
导出结果（因为输出文件output.txt在hdfs的/user/root/output.txt，而且是已序列化文件存储的，直接打开看不到内容），可以用命令导出到本地文件系统
命令：&./mahout seqdumper &-s output.txt & -o /usr/hadoop/output/pfp.txt 注意这里必须先建立本地文件/usr/hadoop/output/pfp.txt&
分析pfp&growth的源码实现
搜索此文相关文章：此文来自: 马开东博客
网址: 站长QQ
Mahout:2-&PFPGrowth分布式频繁模式挖掘&ParallelFrequentPatternMining&_博客园相关文章
博客园_总排行榜
博客园_最新
博客园_月排行榜
博客园_周排行榜
博客园_日排行榜2633人阅读
算法&数据结构（18）
数据挖掘（4）
算法分析：/blog/700740
算法实现：
* FPGrowth算法的主要思想：
* 1. 构造频繁1项集：遍历初始数据集构造频繁1项集，并作为项头表，建立将指向fpTree节点对应元素的引用
* 2. 构造FPTree：再次遍历初始数据集，对于每一条事务中的元素，根据频繁1项集中元素的顺序排序，
* 由此建立FPTree，记录每条事务的节点在同一条路径上出再的节点次数;
* 3. 逆序遍历在步骤1中构造的项头表，根据其提供的引用指针，找出fpTree中由该节点到根节点的路径，
* 即生成每个频繁元素的条件模式基
* 4.　根据每个频繁元素对应的条件模式基，生成其对应的条件fpTree，并删除树中节点记数不满足给定的最小支持度的节点
* 5.　对于每一颗条件fpTree，生成所有的从根节点到叶子节点的路径，由路径中的集合生成其所有非空子集
* 所有这些非空子集和每一个频繁1项集中的元素共同构成了原始数据集中的频繁集
Java代码Item.java：
package com.ustc.fpG
import java.util.ArrayL
import java.util.L
public class Item implements Comparable {
&private S
&private Item preI // 前继节点Item
&private List&Item& nextItem = new ArrayList&Item&(); // 后续节点Item
&private I // 关联节点
&public Item() {
&public Item(String value) {
&&this.value =
&public void addCounter() {
&&this.counter += 1;
&public Item getSibling() {
&public void setSibling(Item sibling) {
&&this.sibling =
&public void addNextItem(Item item) {
&&this.nextItem.add(item);
&public List&Item& getNextItem() {
&&return this.nextI
&public String getValue() {
&public void setValue(String value) {
&&this.value =
&public Item getPreItem() {
&&return preI
&public void setPreItem(Item preItem) {
&&this.preItem = preI
&public int getCounter() {
&public void setCounter(int counter) {
&&this.counter =
&public int compareTo(Object o) {
&&Item i = (Item)
&&if (this.counter & i.counter) {
&&&value = -1;
&&} else if (this.counter == i.counter) {
&&&value = 0;
&&} else {
&&&value = 1;
Java代码FPGrowth.java：
package com.ustc.fpG
import java.io.BufferedR
import java.io.F
import java.io.FileNotFoundE
import java.io.FileR
import java.io.IOE
import java.util.ArrayL
import java.util.A
import java.util.HashM
import java.util.L
import java.util.M
import java.util.S
public class FPGrowth {
&private int minS
& * @param args
&public static void main(String[] args) {
&&FPGrowth fpg = new FPGrowth();
&&fpg.setMinSup(1000);
&&List&String& data = fpg.buildData(&retail.dat&);
&&Item[] f1Items = fpg.buildF1Items(data);
&&Map&String, List&String&& condB
&&//Item fpTree = fpg.buildFPTree(data, f1Items);
&&fpg.buildFPTree(data, f1Items);
&&// fpg.fpGrowth();
&&fpg.printFPTree(fpTree);
&&fpg.printF1Items(f1Items);*/
&&condBase = fpg.buildCondBase(f1Items);
&//&fpg.printCondBase(condBase);
&&Map&String, Item& condFPTree = fpg.buildCondFPTree(condBase);
&//&fpg.printCondFPTree(condFPTree);
&&//输出频繁子集
&&Map&String, List&List&String&&& fpSetMap = fpg.fpGrowth(condFPTree);
&&fpg.printFPSet(fpSetMap);
& * 输出频繁集
&public void printFPSet(Map&String, List&List&String&&& fpSetMap){
&&List&List&String&& fpS
&&Set&String& items = fpSetMap.keySet();
&&for(String item : items){
&&&System.out.println(item);
&&&fpSet = fpSetMap.get(item);
&&&for (int i = 0; i & fpSet.size(); i++) {
&&&&for (String str : fpSet.get(i)) {
&&&&//&if(str != null && str.length() & 0){
&&&&&&System.out.print(str + &, &);
&&&&System.out.println(item);
&// 输出fpTree
&public void printFPTree(Item root) {
&&System.out.print(root.getValue() + &, & + root.getCounter() + & &
&&&&+ root.getNextItem().size() + &: &);
&&List&Item& subItems = root.getNextItem();
&&if (subItems.size() != 0) {
&&&for (int i = 0; i & subItems.size(); i++) {
&&&&printFPTree(subItems.get(i));
&&&System.out.println();
&// 输出频繁1项集
&public void printF1Items(Item[] f1Items) {
&&for (Item item : f1Items) {
&&&while ((item = item.getSibling()) != null) {
&&&&System.out.print(&item: & + item.getValue() + &: &
&&&&&&+ item.getCounter() + & ,&);
&&&&if (item.getPreItem() != null) {
&&&&&System.out.println(item.getPreItem().getValue());
&&&System.out.println();
&// 输出条件模式基
&public void printCondBase(Map&String, List&String&& condBaseMap) {
&&Set&String& items = condBaseMap.keySet();
&&List&String& conB
&&for (String item : items) {
&&&System.out.print(&Item: & + item);
&&&conBase = condBaseMap.get(item);
&&&System.out.println(&, & + conBase.size());
&&&for (String str : conBase) {
&&&&System.out.println(str + & &);
&// 输出条件fp树
&public void printCondFPTree(Map&String, Item& condFPTreeMap) {
&&Set&String& items = condFPTreeMap.keySet();
&&for (String item : items) {
&&&System.out.println(&Item: & + item);
&&&this.printFPTree(condFPTreeMap.get(item));
& * 1.构造数据集
&public List&String& buildData(String...fileName) {
&&List&String& data = new ArrayList&String&();
&&if(fileName.length !=0){
&&&File file = new File(fileName[0]);
&&&&BufferedReader reader = new BufferedReader(new FileReader(file));
&&&&while( (line = reader.readLine()) != null){
&&&&&data.add(line);
&&&} catch (FileNotFoundException e) {
&&&&e.printStackTrace();
&&&} catch (IOException e) {
&&&&e.printStackTrace();
&&&data.add(&I1 I2 I5&);
&&&data.add(&I2 I4&);
&&&data.add(&I2 I3&);
&&&data.add(&I1 I2 I4&);
&&&data.add(&I1 I3&);
&&&data.add(&I2 I3&);
&&&data.add(&I1 I3&);
&&&data.add(&I1 I2 I3 I5&);
&&&data.add(&I1 I2 I3&);
& * 2.构造频繁1项列表，同时作为树的项头表
&public Item[] buildF1Items(List&String& data) {
&&List&Item& itemList = new ArrayList&Item&();
&&Map&String, Item& resultMap = new HashMap&String, Item&();
&&for (String trans : data) {
&&&String[] items = trans.trim().split(& &);
&&&for (String item : items) {
&&&&if(resultMap.get(item) == null){
&&&&&Item newItem = new Item();
&&&&&newItem.setValue(item);
&&&&&newItem.setCounter(1);
&&&&&resultMap.put(item, newItem);
&&&&}else{
&&&&&resultMap.get(item).addCounter();
&&Set&String& keySet = resultMap.keySet();
&&for(String key : keySet){
&&&itemList.add(resultMap.get(key));
&&List&Item& result = new ArrayList&Item&();
&&// 把支持度小于minSup的项从列表中删除
&&for (int i = 0; i & itemList.size(); i++) {
&&&if (itemList.get(i).getCounter() &= this.minSup) {
&&&&result.add(itemList.get(i));
&&// 对列表进行排序
&&Item[] f1Items = result.toArray(new Item[0]);
&&Arrays.sort(f1Items);
&&return f1I
& * 3. 构造fpTree
&public Item buildFPTree(List&String& data, Item[] f1Items) {
&&Item fpTree = new Item();
&&List&Item& subI
&&// 对每一条事务进行处理
&&for (String trans : data) {
&&&// 得出每条事件中涉及的元素项
&&&String[] items = trans.trim().split(& &);
&&&// 对items中的元素按其在频繁1项集中出现次数排序
&&&items = sortItem(items, f1Items);
&&&// 把items的值加入到fpTree中
&&&subItems = fpTree.getNextItem();
&&&if (subItems.size() == 0) {
&&&&this.addLeaf(fpTree, items, f1Items);
&&&} else {
&&&&Item temp =
&&&&for (int i = 0; i & items. i++) {
&&&&&int j = 0;
&&&&&int size = subItems.size();
&&&&&for (; j & subItems.size(); j++) {
&&&&&&if (subItems.get(j).getValue().equals(items[i])) {
&&&&&&&temp = subItems.get(j);
&&&&&&&temp.addCounter();
&&&&&&&subItems = temp.getNextItem();
&&&&&if (j == size) {
&&&&&&if (temp == null) {
&&&&&&&this.addLeaf(fpTree, Arrays.copyOfRange(items, i,
&&&&&&&&&items.length), f1Items);
&&&&&&} else {
&&&&&&&this.addLeaf(temp, Arrays.copyOfRange(items, i,
&&&&&&&&&items.length), f1Items);
&&return fpT
& * 3.1 对元素数组根据其在f1中出面的频繁进行排序
& * @param items
& * @return
&public String[] sortItem(String[] items, Item[] f1Items) {
&&String[] temp = new String[f1Items.length];
&&for (String item : items) {
&&&for (i = 0; i & f1Items. i++) {
&&&&if (item.equals(f1Items[i].getValue())) {
&&&&&temp[i] =
&&List&String& list = new ArrayList&String&();
&&int j = 0;
&&for (i = 0; i & temp. i++) {
&&&if (temp[i] != null) {
&&&&list.add(temp[i]);
&&return list.toArray(new String[0]);
& * 3.2 给FPTree的节点添加子节点序列
& * @param preItem
& * @param items
&public void addLeaf(Item preItem, String[] items, Item[] f1Items) {
&&if (items.length & 0) {
&&&Item item = new Item(items[0]);
&&&item.setCounter(1);
&&&item.setPreItem(preItem);
&&&preItem.addNextItem(item);
&&&for (Item i : f1Items) {
&&&&if (i.getValue().equals(items[0])) {
&&&&&Item temp =
&&&&&while (temp.getSibling() != null) {
&&&&&&temp = temp.getSibling();
&&&&&temp.setSibling(item);
&&&if (items.length & 1) {
&&&&addLeaf(item, Arrays.copyOfRange(items, 1, items.length),
&&&&&&f1Items);
&// 4.生成条件模式基
&public Map&String, List&String&& buildCondBase(Item[] f1Items) {
&&Item item = // 横向处理时的当前节点
&&Item preItem = // 横向处理的当前节点对应的纵向节点
&&int counter = 0;
&&Map&String, List&String&& condBaseMap = new HashMap&String, List&String&&();
&&List&String& conditionB // 条件模式基
&&// 逆向遍历频繁1项集(但不需处理其第一项)
&&for (int i = f1Items.length - 1; i & 0; i--) {
&&&conditionBase = new ArrayList&String&();
&&&item = f1Items[i].getSibling();
&&&while (item != null) { // 横向处理
&&&&counter = item.getCounter();
&&&&preItem = item.getPreItem();
&&&&data = new StringBuffer();
&&&&while (preItem.getValue() != null) { // 纵向处理
&&&&&data.append(preItem.getValue() + & &);
&&&&&preItem = preItem.getPreItem();
&&&&for (int j = 0; j & j++) {
&&&&&if (data.toString().trim() != &&
&&&&&&&&& data.toString().trim().length() & 0) {
&&&&&&conditionBase.add(data.toString().trim());
&&&&item = item.getSibling();
&&&condBaseMap.put(f1Items[i].getValue(), conditionBase);
&&return condBaseM
&// 5.生成条件FP树
&public Map&String, Item& buildCondFPTree(
&&&Map&String, List&String&& condBaseMap) {
&&Map&String, Item& condFPTreeMap = new HashMap&String, Item&();
&&List&String& condB
&&Item condFPT
&&Set&String& items = condBaseMap.keySet();
&&for (String item : items) {
&&&condBase = condBaseMap.get(item);
&&&condFPTree = this
&&&&&.buildFPTree(condBase, this.buildF1Items(condBase));
&&&// 删除condFPTree树中节点出现次数少于最小支持度的点
&&&this.delLTminSup(condFPTree);
&&&condFPTreeMap.put(item, condFPTree);
&&return condFPTreeM
& * 5.1& 删除树中节点计数小于最小支持度的节点
& * @param root
&public void delLTminSup(Item root) {
&&List&Item& subItems = root.getNextItem();
&&if (subItems.size() != 0) {
&&&for (int i = 0; i & subItems.size(); i++) {
&&&&if (subItems.get(i).getCounter() & this.minSup) {
&&&&&subItems.remove(i);
&&&&} else {
&&&&&delLTminSup(subItems.get(i));
& * 6.产生频繁模式 根据前面生成的条件FP树，分别产生相应元素相关的频繁模式
&public Map&String,List&List&String&&& fpGrowth(Map&String, Item& condFPTreeMap) {
&&List&List&String&&
&&Map&String, List&List&String&&& resultMap = new HashMap&String, List&List&String&&&();
&&Set&String& items = condFPTreeMap.keySet();
&&Item condFPTree =
&&List&String& pathL // 一个条件fp树中所有的路径
&&List&String& stack = new ArrayList&String&();
&&for (String item : items) {
&&&pathList = new ArrayList&String&();
&&&condFPTree = condFPTreeMap.get(item);
&&&buildPath(stack, condFPTree, pathList);
&&&for(String str : pathList){
&&&&result = new ArrayList&List&String&&();
&&&&if(str.trim().length() != 0){
&&&&&String[] temp = str.trim().split(& &);
&&&&&List&String& nodeList = new ArrayList&String&();
&&&&&for(String t : temp){
&&&&&&nodeList.add(t);
&&&&&buildSubSet(nodeList, result);
&&&&&if(resultMap.get(item) == null){
&&&&&&resultMap.put(item, result);
&&&&&}else{
&&&&&&List&List&String&& list = resultMap.get(item);
&&&&&&for( int& i = 0; i & result.size(); i++){
&&&&&&&list.add(result.get(i));
&&&&&&resultMap.put(item, list);
&&return resultM
&// 6.1 生成树的每一条路径
&public void buildPath(List&String& stack, Item root, List&String& pathList) {
&&if (root != null) {
&&&stack.add(root.getValue());
&&&if (root.getNextItem().size() == 0) {
&&&&changeToPath(stack, pathList); // 把值栈中的值转化为路径
&&&} else {
&&&&List&Item& items = root.getNextItem();
&&&&for (int i = 0; i & items.size(); i++) {
&&&&&buildPath(stack, items.get(i), pathList);
&&&stack.remove(stack.size() - 1);
& * 6.1.1 把值栈中的值转化为路径
& * @param path
& * @param pathList
&public void changeToPath(List&String& path, List&String& pathList) {
&&StringBuffer sb = new StringBuffer();
&&for (int i = 0; i & path.size(); i++) {
&&&if (path.get(i) != null) {
&&&&sb.append(path.get(i) + & &);
&&pathList.add(sb.toString().trim());
& * 6.2 生成子集
& * @param sourceSet
& * @param result
&public void buildSubSet(List&String& sourceSet, List&List&String&& result) {
&&if (sourceSet.size() == 1) {
&&&List&String& set = new ArrayList&String&();
&&&set.add(sourceSet.get(0));
&&&result.add(set);
&&} else if (sourceSet.size() & 1) {
&&&buildSubSet(sourceSet.subList(0, sourceSet.size() - 1), result);
&&&int size = result.size();
&&&List&String& single = new ArrayList&String&();
&&&single.add(sourceSet.get(sourceSet.size() - 1));
&&&result.add(single);
&&&List&String&
&&&for (int i = 0; i & i++) {
&&&&clone = new ArrayList&String&();
&&&&for (String str : result.get(i)) {
&&&&&clone.add(str);
&&&&clone.add(sourceSet.get(sourceSet.size() - 1));
&&&&result.add(clone);
&public void setMinSup(int minSup) {
&&this.minSup = minS
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：234372次
积分：3329
积分：3329
排名：第7175名
原创：85篇
转载：54篇
评论：37条
(3)(7)(11)(13)(3)(7)(10)(1)(2)(1)(1)(11)(7)(11)(39)(12)