Java 迭代 apriori算法

最新推荐文章于 2024-04-23 15:52:51 发布
最新推荐文章于 2024-04-23 15:52:51 发布
阅读量624 收藏
点赞数

 

 

http://download.csdn.net/detail/huangyongjie986123/3976324

 

http://blog.csdn.net/wangyunyun00/article/details/38273213

 

http://blog.sina.com.cn/s/blog_6efce07e0101309a.html

 

https://zhidao.baidu.com/question/40651338.html

 

http://cxl2012.iteye.com/blog/2059218

 

http://www.cnblogs.com/amboyna/archive/2007/09/25/904804.html

 

http://www.tceic.com/3j1695j3312h3169g551g448.html

 

http://www.cnblogs.com/selene/p/5844686.html

 

 

http://blog.csdn.net/u010498696/article/details/45641719  apriori算法代码Java

 

 http://blog.sina.com.cn/s/blog_e7fb9d080102v9o0.html  java 离散数学 http://blog.163.com/xiaohui_1123@126/blog/static/3980524020109784356915/求集合的子集算法 

 http://blog.csdn.net/foreverbu/article/details/37567111   http://www.cnblogs.com/lixusign/archive/2012/06/13/2548124.html决策树算法    http://www.xqbase.com/computer/search_iterative.htm   迭代算法 http://blog.csdn.net/lg1259156776/article/details/48340829

 

 

 

 

 

 

 

===============================================

 

package com.cxl.algorithm;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

public class AprioriMyself
{

 private static final double MIN_SUPPROT = 0.2;// 最小支持度
 private static boolean endTag = false;// 循环状态
  static List<List<String>> record = new ArrayList<List<String>>();// 数据集

 public static void main(String args[])
 {

  try{
  String encoding = "GBK"; // 字符编码(可解决中文乱码问题 )
  File file = new File("simple.txt");
  if (file.isFile() && file.exists())
  {
   InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);
  
   BufferedReader bufferedReader = new BufferedReader(read);
   
   String lineTXT = null;
   
   while ((lineTXT = bufferedReader.readLine()) != null)
   {
    // 读一行文件
    String[] lineString = lineTXT.split("      ");
    
    List<String> lineList = new ArrayList<String>();
    
    for (int i = 0; i < lineString.length; i++)
    {        
     lineList.add(lineString[i]);          
    }
    System.out.println("数组输出："+lineTXT);
    
    System.out.println("list集合输出：");
     
  
     Iterator i = lineList.iterator();

     while( i.hasNext() )
         {
          String  me =   (String) i.next();
          System.out.print( me +"  " );       

         }
     System.out.println( "  " );
    
   }  
    
  }
 } catch (Exception e)
 {
  System.out.println("读取文件内容操作出错");
  e.printStackTrace();
 }
}
} 
  /**
   * 读取txt数据
   *
   * @return
   */
  /*
  List<List<String>> record = new ArrayList<List<String>>();

  try
  {
   String encoding = "GBK"; // 字符编码(可解决中文乱码问题 )
   File file = new File("simple.txt");
   if (file.isFile() && file.exists())
   {
    InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);
    BufferedReader bufferedReader = new BufferedReader(read);
    String lineTXT = null;
    while ((lineTXT = bufferedReader.readLine()) != null)
    {// 读一行文件
     String[] lineString = lineTXT.split("      ");
     List<String> lineList = new ArrayList<String>();
     for (int i = 0; i < lineString.length; i++)
     {// 处理矩阵中的T、F、YES、NO
      if (lineString[i].endsWith("T") || lineString[i].endsWith("YES"))      
       
       lineList.add(record.get(0).get(i));
      
      else if (lineString[i].endsWith("F") || lineString[i].endsWith("NO"))
       ;// F，NO记录不保存
      else
       lineList.add(lineString[i]);
     }

      Iterator i = lineList.iterator();

      while( i.hasNext() )
          {
           String  me =   (String) i.next();
           System.out.print( me +"  " );       

          }
      System.out.println( "  " );
     record.add(lineList);
    }
    read.close();
   } else
   {
    System.out.println("找不到指定的文件！");
   }
  } catch (Exception e)
  {
   System.out.println("读取文件内容操作出错");
   e.printStackTrace();
  }
         */
 
  

 

以上代码输出：

数组输出：TID      I1      I2      I3      I4      I5
list集合输出：
TID  I1  I2  I3  I4  I5   
数组输出：T100      T      T      F      F      T
list集合输出：
T100  T  T  F  F  T   
数组输出：T200      F      T      F      T      F
list集合输出：
T200  F  T  F  T  F   
数组输出：T300      F      T      T      F      F
list集合输出：
T300  F  T  T  F  F   
数组输出：T400      T      T      F      T      F
list集合输出：
T400  T  T  F  T  F   
数组输出：T500      T      F      T      F      F
list集合输出：
T500  T  F  T  F  F   
数组输出：T600      F      T      T      F      F
list集合输出：
T600  F  T  T  F  F   
数组输出：T700      T      F      T      F      F
list集合输出：
T700  T  F  T  F  F   
数组输出：T800      T      T      T      F      T
list集合输出：
T800  T  T  T  F  T   
数组输出：T900      T      T      T      F      F
list集合输出：
T900  T  T  T  F  F   

=================================

package com.cxl.algorithm;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

public class AprioriMyself
{

 private static final double MIN_SUPPROT = 0.2;// 最小支持度
 private static boolean endTag = false;// 循环状态
  static List<List<String>> record = new ArrayList<List<String>>();// 数据集

 public static void main(String args[])
 {

  try{
  String encoding = "GBK"; // 字符编码(可解决中文乱码问题 )
  File file = new File("simple.txt");
  if (file.isFile() && file.exists())
  {
   InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);
  
   BufferedReader bufferedReader = new BufferedReader(read);
   
   String lineTXT = null;
   
   
   
   while ((lineTXT = bufferedReader.readLine()) != null)
   {
    System.out.println("数组输出："+lineTXT);
    // 读一行文件
    String[] lineString = lineTXT.split("      ");
            
    List<String> lineList = new ArrayList<String>();
        
    for (int i = 0; i < lineString.length; i++)
    {  
     if(lineString[i].equals("T") )
     {
      lineList.add(record.get(0).get(i));  
     }
     else if(lineString[i].equals("F"))
     {
      ;
     }
     else  lineList.add(lineString[i]);          
    }
    
    record.add(lineList);
    
    
    System.out.println("list集合输出：");
     
  
     Iterator i = lineList.iterator();

     while( i.hasNext() )
         {
          String  me =   (String) i.next();
          System.out.print( me +"  " );       

         }
     System.out.println( "  " );
    
   }  
    
  }
 } catch (Exception e)
 {
  System.out.println("读取文件内容操作出错");
  e.printStackTrace();
 }
}
} 

 

代码输出：

数组输出：TID      I1      I2      I3      I4      I5
list集合输出：
TID  I1  I2  I3  I4  I5   
数组输出：T100      T      T      F      F      T
list集合输出：
T100  I1  I2  I5   
数组输出：T200      F      T      F      T      F
list集合输出：
T200  I2  I4   
数组输出：T300      F      T      T      F      F
list集合输出：
T300  I2  I3   
数组输出：T400      T      T      F      T      F
list集合输出：
T400  I1  I2  I4   
数组输出：T500      T      F      T      F      F
list集合输出：
T500  I1  I3   
数组输出：T600      F      T      T      F      F
list集合输出：
T600  I2  I3   
数组输出：T700      T      F      T      F      F
list集合输出：
T700  I1  I3   
数组输出：T800      T      T      T      F      T
list集合输出：
T800  I1  I2  I3  I5   
数组输出：T900      T      T      T      F      F
list集合输出：
T900  I1  I2  I3   

 

===================================

 

 

package com.cxl.algorithm;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

public class AprioriMyself
{

 private static final double MIN_SUPPROT = 0.2;// 最小支持度
 private static boolean endTag = false;// 循环状态
 static List<List<String>> record = new ArrayList<List<String>>();// 数据集

 public static void main(String args[])
 {

  try
  {
   String encoding = "GBK"; // 字符编码(可解决中文乱码问题 )
   File file = new File("simple.txt");
   if (file.isFile() && file.exists())
   {
    InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);

    BufferedReader bufferedReader = new BufferedReader(read);

    String lineTXT = null;

    while ((lineTXT = bufferedReader.readLine()) != null)
    {
     System.out.println("数组输出：" + lineTXT);
     // 读一行文件
     String[] lineString = lineTXT.split("      ");

     List<String> lineList = new ArrayList<String>();

     for (int i = 0; i < lineString.length; i++)
     {
      if (lineString[i].equals("T"))
      {
       lineList.add(record.get(0).get(i));
      } else if (lineString[i].equals("F"))
      {
       ;
      } else
       lineList.add(lineString[i]);
     }

     record.add(lineList);

     System.out.println("list集合输出：");

     Iterator i = lineList.iterator();

     while (i.hasNext())
     {
      String me = (String) i.next();
      System.out.print(me + "  ");

     }
     System.out.println("  ");

    }

   }
  } catch (Exception e)
  {
   System.out.println("读取文件内容操作出错");
   e.printStackTrace();
  }

  List<List<String>> record2 = new ArrayList<List<String>>();// 数据集

  record2 = record;

  for (int w = 1; w < record2.size(); w++)
  {

   int count = 0;
   for (int i = 1; i < record.size(); i++)
   {

    boolean notHaveThisList = false;

    for (int k = 1; k < record2.get(w).size(); k++)
    {// 判断record.get(i)是否包含list
     boolean thisRecordHave = false;
     for (int j = 1; j < record.get(i).size(); j++)
     {
      if (record2.get(w).get(k).equals(record.get(i).get(j))) // list。get(k)在record。get(i)中能找到
       thisRecordHave = true;
     }
     if (!thisRecordHave)
     {
      // 只要有一个list元素找不到，则退出其余元素比较,进行下一个record。get(i)比较
      notHaveThisList = true;
      break;
     }
    }

    if (notHaveThisList == false)
     count++;
    

   }
   
   System.out.println(count);  //输出每个集合在总集合中的包含个数，这本书重要。
  }

 }

}

 

 

输出结果：

数组输出：TID      I1      I2      I3      I4      I5
list集合输出：
TID  I1  I2  I3  I4  I5   
数组输出：T100      T      T      F      F      T
list集合输出：
T100  I1  I2  I5   
数组输出：T200      F      T      F      T      F
list集合输出：
T200  I2  I4   
数组输出：T300      F      T      T      F      F
list集合输出：
T300  I2  I3   
数组输出：T400      T      T      F      T      F
list集合输出：
T400  I1  I2  I4   
数组输出：T500      T      F      T      F      F
list集合输出：
T500  I1  I3   
数组输出：T600      F      T      T      F      F
list集合输出：
T600  I2  I3   
数组输出：T700      T      F      T      F      F
list集合输出：
T700  I1  I3   
数组输出：T800      T      T      T      F      T
list集合输出：
T800  I1  I2  I3  I5   
数组输出：T900      T      T      T      F      F
list集合输出：
T900  I1  I2  I3   
2
2
4
1
4
4
4
1
2

 

 ============================================

  public static void main(String[] args) {
       
       
        byte tmp=1<<4;
        System.out.println(tmp );
       
        for( byte b1 = 0; b1<16 ;b1++)
        {
       for(byte i=0; i<8; i++) {   //System.out.print(number &(tmp>>>=1));
       
       System.out.print( (b1 & (tmp>>>=1) ) > 0 ? 1 : 0 );
      }
        System.out.println("下一个元素是：" );
        tmp=1<<4;
        }
      

       }

 

 

输出结果：16
00000000下一个元素是：
00010000下一个元素是：
00100000下一个元素是：
00110000下一个元素是：
01000000下一个元素是：
01010000下一个元素是：
01100000下一个元素是：
01110000下一个元素是：
10000000下一个元素是：
10010000下一个元素是：
10100000下一个元素是：
10110000下一个元素是：
11000000下一个元素是：
11010000下一个元素是：
11100000下一个元素是：
11110000下一个元素是：

 

=============================

 

 

 

 

package com.cxl.algorithm;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

public class AprioriMyself
{ 
       public static void main(String[] args) {
       
        List<String> record = new ArrayList<String>();
       
      String []a = {"A","B","C","D"};
      String b="" ;
        byte tmp=1<<4;
        System.out.println(tmp );
               
        for( byte b1 = 0; b1<16 ;b1++)
        {
       for(byte i=0; i<8; i++) {  
        
        if(i<4)
        {          
         int ii =(( b1 & (tmp>>>=1) ) > 0 ? 1 : 0 );         
         if(ii!=1)
          b=b+a[i];
         if(i==3) record.add(b);
        }               
      }
       
       b="";
       record.add("**********"); //前后每个子集元素 的分割符号      
       tmp=1<<4;
        }
      
        for(int i =0  ; i<record.size(); i++)
        {        
         System.out.println( record.get(i));                        
        }           
       }
}

 输出：

16
ABCD
**********
ABC
**********
ABD
**********
AB
**********
ACD
**********
AC
**********
AD
**********
A
**********
BCD
**********
BC
**********
BD
**********
B
**********
CD
**********
C
**********
D
**********

**********

 我花了一天的时间研究 —— 求 一个4元素集合的所有子集 并输出 。

哈哈哈，原理搞通了，

如果你看到这篇文章了，  你可以继续改进代码， 求 任意集合 的所有子集  。

 

 

 

 

 

 

 

MAGANG255
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Apriori算法完整Java代码
11-19
在Java编程语言中实现Apriori算法，需要设计数据结构来存储项集和它们的支持度，以及高效地处理候选集生成和支持度计算。通常，可以使用Map来存储项集及其支持度，用集合来表示候选集，用迭代器来遍历数据库中的交易...
Apriori算法 java实现
05-28
`apriori.java`是Apriori算法的Java实现文件。这个文件可能包含了以下关键部分： 1. 数据预处理：从Excel文件中读取数据，转换成项集（如商品列表）。 2. 支持度计算：定义一个函数来计算项集的支持度，这是评估项集...
数据挖掘Java——Apriori算法的实现
qq_54162207的博客
12-18 3389
首先扫描数据库中所需要进行分析的数据，在设置完支持度以及置信度以后，在最小支持度的支持下产生频繁项，即统计所有项目集中包含一个或一个以上的元素频数，找出大于或者等于设置的支持度的项目集。其次就是频繁项的自连接。在方法体内部，遍历所有的频繁项目集，得到每一项频繁项目集的非空子集集合subSet，遍历每一项频繁项目集的非空子集，以此非空子集和此频繁项目集作为参数，调用isConfidence()方法判断是否满足置信度大于最小置信度，若满足，则输出此非空子集==>非空子集的补集。或者说几个数据关联出现的概率。
Java实现基于MapReduce的Apriori算法
qq_66418915的博客
04-23 1245
在Hadoop环境下，使用Java实现基于MapReduce的Apriori算法
Java实现Apriori算法
weixin_45685353的博客
06-22 5100
简介： Apriori算法是第一个关联规则挖掘算法，也是最经典的算法。它利用逐层搜索的迭代方法找出数据库中项集的关系，以形成规则，其过程由连接（类矩阵运算）与剪枝（去掉那些没必要的中间结果）组成。该算法中项集的概念即为项的集合。包含K个项的集合为k项集。项集出现的频率是包含项集的事务数，称为项集的频率。如果某项集满足最小支持度，则称它为频繁项集。 基本思想： 首先扫描数据库中所需要进行分析的数据，在设置完支持度以及置信度以后，在最小支持度的支持下产生频繁项，即统计所有项目集中包含一个或一个以上的元素频数，找
【Java】Apriori算法
编程记录，亲测有效
12-14 6059
Apriori算法是一种最基本的根据事务记录求解关联的算法。在1994年已经由Agrawal和Srikant提出。也就是那个成功在一大堆顾客的购买记录中，求解出买完啤酒还要买尿布的结论的著名数据挖掘算法。现在关联算法已经发展得多种多样，无数学术论文的产生，让关联求解更加多样化，但都是依据这个Apriori作进一步发展。 利用Java完成Apriori算法其实很简单，在贴代码之前，首先讲解Apri
apriori java_频繁模式挖掘apriori算法介绍及Java实现
weixin_31629913的博客
02-12 466
频繁模式是频繁地出如今数据集中的模式(如项集、子序列或者子结构)。比如。频繁地同一时候出如今交易数据集中的商品(如牛奶和面包)的集合是频繁项集。一些基本概念支持度：support(A=>B)=P(A并B)置信度：confidence(A=>B)=P(B|A)频繁k项集：假设项集I的支持度满足提前定义的最小支持度阈值。则称I为频繁项集，包括k个项的项集称为k项集。算法思想Apriori算...
数据挖掘-Apriori算法的java实现
Hrenhua的博客
11-19 2365
1. Apriori算法思想 　　对于Apriori算法，我们使用支持度来作为我们判断频繁项集的标准。Apriori算法的目标是找到最大的K项频繁集。这里有两层意思，首先，我们要找到符合支持度标准的频繁集。但是这样的频繁集可能有很多。第二层意思就是我们要找到最大个数的频繁集。比如我们找到符合支持度的频繁集AB和ABE，那么我们会抛弃AB，只保留ABE，因为AB是2项频繁集，而ABE是3项频繁集。那么具体的，Apriori算法是如何做到挖掘K项频繁集的呢？ Apriori算法采用了迭代的方法，先搜索出候选1项
Apriori算法学习和java实现
stay hungry ! stay foolish!
05-12 689
关联规则挖掘可以发现大量数据中项集之间有趣的关联或相关联系。一个典型的关联规则挖掘例子是购物篮分析，即通过发现顾客放入其购物篮中的不同商品之间的联系，分析顾客的购物习惯，从而可以帮助零售商指定营销策略，引导销售等。国外有"啤酒与尿布"的故事，国内有泡面和火腿的故事。Apriori算法学习和java实现本文以Apriori算法为例介绍关联规则挖掘并以Java实现。什么是关联规则：对于记录的集合D和记...
Apriori算法整理
qq_41224370的博客
06-26 2381
为了完成实践课，特意整理了Apriori算法，主要是以Java语言实现算法，MYSQL存储数据集。
Apriori算法的java实现
marho
08-28 2570
介绍 Apriori算法是一个经典的数据挖掘算法，Apriori的单词的意思是"先验的"，说明这个算法是具有先验性质的，就是说要通过上一次的结果推导出下一次的结果，这个如何体现将会在下面的分析中会慢慢的体现出来。Apriori算法的用处是挖掘频繁项集的，频繁项集粗俗的理解就是找出经常出现的组合，然后根据这些组合最终推出我们的关联规则。 Apriori算法原理 Apriori算法是一种逐层搜索
java实现Apriori算法
01-21
6. **Java实现**：在Java中实现Apriori，首先需要读取`dataset.txt`文件，将数据转换为事务集合，然后用迭代的方式执行Apriori算法。这通常涉及创建一个事务类来存储每个交易，一个项集类来表示可能的频繁项集，以及...
java实现apriori算法
12-23
在Java中实现Apriori算法，需要理解其核心原理和步骤，然后通过编程语言来构建相应的数据结构和逻辑流程。 1. **算法原理**： Apriori算法基于两个关键原则：频繁项集的闭包性质和提前剪枝。首先，它寻找最小支持...
Java 实现 Apriori 算法
06-29
**Java实现Apriori算法详解** Apriori算法是一种经典的关联规则学习算法，主要用于发现大量数据集中的频繁项集和强关联规则。在电子商务、市场篮子分析、医学诊断等领域有着广泛的应用。Java作为一种跨平台的编程...
pi_heif-0.17.0-cp39-cp39-manylinux_2_31_armv7l.whl
最新发布
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
ubuntu20.04-ssh9.8p1-ssl3.0.14-focal-deb-amd64升级加固脚本.zip
07-27
若有新版本请查看文章最后附件地址：https://blog.csdn.net/liuxin638507/article/details/132450367 特点： 1、同时升级openssh与openssl，采用deb包形式，一键快速升级版本，无需每台单独再次进行编译， 2、隐藏openssh-版本号(openssh9.8p1及之后隐藏版本号还未找到方法) 3、已默认安全加固（已有配置跳过） 安装： 执行 bash upgrade_ssl_ssh_ubuntu.sh 进行安装 注意，升级安装后，确保sshd服务正常，请新开终端进行验证测试 验证 openssl版本： openssl version OpenSSL 3.0.14 4 Jun 2024 (Library: OpenSSL 3.0.14 4 Jun 2024) openssh版本： ssh -V OpenSSH_9.8p1, OpenSSL 3.0.14 4 Jun 2024
avif-0.5.0-cp36-cp36m-manylinux1_i686.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
教务管理系统-毕业设计.zip
07-27
教务管理系统-毕业设计.zip
用java写Apriori算法
05-04
以下是用 Java 实现 Apriori 算法的示例代码： ```java import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class Apriori { public static void main(String[] args) { // 构造事务数据库 List<List<String>> transactions = new ArrayList<>(); transactions.add(new ArrayList<String>() {{ add("A"); add("B"); add("C"); }}); transactions.add(new ArrayList<String>() {{ add("A"); add("C"); add("D"); }}); transactions.add(new ArrayList<String>() {{ add("B"); add("C"); add("E"); }}); transactions.add(new ArrayList<String>() {{ add("A"); add("C"); add("D"); }}); transactions.add(new ArrayList<String>() {{ add("B"); add("E"); }}); // 设置支持度阈值和置信度阈值 double minSupport = 0.4; double minConfidence = 0.6; // 调用 Apriori 算法进行频繁项集和关联规则挖掘 Map<List<String>, Double> frequentItemsets = apriori(transactions, minSupport); List<AssociationRule<String>> associationRules = generateAssociationRules(frequentItemsets, minConfidence); // 输出结果 System.out.println("频繁项集："); for (Map.Entry<List<String>, Double> entry : frequentItemsets.entrySet()) { System.out.println(entry.getKey() + " : " + entry.getValue()); } System.out.println("关联规则："); for (AssociationRule<String> rule : associationRules) { System.out.println(rule); } } /** * Apriori 算法 * * @param transactions 事务数据库 * @param minSupport 支持度阈值 * @return 频繁项集及其支持度 */ public static Map<List<String>, Double> apriori(List<List<String>> transactions, double minSupport) { // 计算候选频繁项集的支持度 Map<List<String>, Double> candidateItemsets = new HashMap<>(); for (List<String> transaction : transactions) { for (String item : transaction) { List<String> itemset = new ArrayList<String>() {{ add(item); }}; if (candidateItemsets.containsKey(itemset)) { candidateItemsets.put(itemset, candidateItemsets.get(itemset) + 1); } else { candidateItemsets.put(itemset, 1.0); } } } // 迭代计算频繁项集 Map<List<String>, Double> frequentItemsets = new HashMap<>(); while (!candidateItemsets.isEmpty()) { // 过滤掉支持度小于阈值的候选频繁项集 candidateItemsets.entrySet().removeIf(entry -> entry.getValue() / transactions.size() < minSupport); // 将剩余的候选频繁项集加入频繁项集列表 frequentItemsets.putAll(candidateItemsets); // 生成下一层的候选频繁项集 candidateItemsets = generateCandidateItemsets(candidateItemsets.keySet()); for (List<String> transaction : transactions) { for (List<String> candidateItemset : candidateItemsets.keySet()) { if (transaction.containsAll(candidateItemset)) { candidateItemsets.put(candidateItemset, candidateItemsets.get(candidateItemset) + 1); } } } } return frequentItemsets; } /** * 生成下一层的候选频繁项集 * * @param itemsets 上一层的频繁项集 * @return 下一层的候选频繁项集 */ private static Map<List<String>, Double> generateCandidateItemsets(Set<List<String>> itemsets) { Map<List<String>, Double> candidateItemsets = new HashMap<>(); for (List<String> itemset1 : itemsets) { for (List<String> itemset2 : itemsets) { if (itemset1.equals(itemset2)) { continue; } List<String> newItemset = new ArrayList<>(itemset1); newItemset.addAll(itemset2); Collections.sort(newItemset); if (!candidateItemsets.containsKey(newItemset)) { candidateItemsets.put(newItemset, 0.0); } } } return candidateItemsets; } /** * 生成关联规则 * * @param frequentItemsets 频繁项集及其支持度 * @param minConfidence 置信度阈值 * @return 关联规则 */ public static List<AssociationRule<String>> generateAssociationRules(Map<List<String>, Double> frequentItemsets, double minConfidence) { List<AssociationRule<String>> associationRules = new ArrayList<>(); for (Map.Entry<List<String>, Double> entry : frequentItemsets.entrySet()) { List<String> itemset = entry.getKey(); double support = entry.getValue() / transactions.size(); if (itemset.size() > 1) { for (int i = 0; i < itemset.size(); i++) { List<String> antecedent = new ArrayList<>(itemset.subList(0, i)); List<String> consequent = new ArrayList<>(itemset.subList(i, itemset.size())); double confidence = support / frequentItemsets.get(antecedent); if (confidence >= minConfidence) { associationRules.add(new AssociationRule<>(antecedent, consequent, support, confidence)); } } } } return associationRules; } /** * 关联规则 * * @param <T> 项集元素类型 */ public static class AssociationRule<T> { private List<T> antecedent; private List<T> consequent; private double support; private double confidence; public AssociationRule(List<T> antecedent, List<T> consequent, double support, double confidence) { this.antecedent = antecedent; this.consequent = consequent; this.support = support; this.confidence = confidence; } public List<T> getAntecedent() { return antecedent; } public List<T> getConsequent() { return consequent; } public double getSupport() { return support; } public double getConfidence() { return confidence; } @Override public String toString() { return antecedent + " => " + consequent + " : Support = " + support + ", Confidence = " + confidence; } } } ``` 这个示例代码中包含 Apriori 算法和关联规则生成的实现，你可以根据自己的需求进行修改和扩展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值