、用Apriori算法分析下列购物单数据，设最小支持度为0.5，最小置信度为 0.4，挖掘频繁项集，找出最强关联规则

Question

**请问第1题和第三题如何做
第三题过程越写越迷糊，都在第2－项集中低于支持度0.5，还高于0.4的置信度，没有关联规则？感觉算错了，有没有会的。

Answer 1

• 你可以看下这个问题的回答https://ask.csdn.net/questions/721471
• 这篇博客也不错, 你可以看下算法上机报告2 ——几种排序算法的实验性能比较（插入排序，归并排序，随机快排，三路随机快排）
• 除此之外, 这篇博客: 一文搞懂高频面试题之四种常用的限流算法，从算法原理到实现，再到对比分析中的 代码实现及测试 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• package project.limiter;
  
  /**
   * Project: AllForJava
   * Title:
   * Description:
   * Date: 2020-09-07 18:38
   * Copyright: Copyright (c) 2020
   *
  * @公众号: 超悦编程
  * @微信号：exzlco
  * @author: 超悦人生
  * @email: [e-mail]
  * @version 1.0
   **/
  
  public class CounterSildeWindowLimiter {
  
      private int windowSize; //窗口大小，毫秒为单位
      private int limit;//窗口内限流大小
      private int splitNum;//切分小窗口的数目大小
      private int[] counters;//每个小窗口的计数数组
      private int index;//当前小窗口计数器的索引
      private long startTime;//窗口开始时间
  
      private CounterSildeWindowLimiter(){}
  
      public CounterSildeWindowLimiter(int windowSize, int limit, int splitNum){
          this.limit = limit;
          this.windowSize = windowSize;
          this.splitNum = splitNum;
          counters = new int[splitNum];
          index = 0;
          startTime = System.currentTimeMillis();
      }
  
      //请求到达后先调用本方法，若返回true，则请求通过，否则限流
      public synchronized boolean tryAcquire(){
          long curTime = System.currentTimeMillis();
          long windowsNum = Math.max(curTime - windowSize - startTime,0) / (windowSize / splitNum);//计算滑动小窗口的数量
          slideWindow(windowsNum);//滑动窗口
          int count = 0;
          for(int i = 0;i < splitNum;i ++){
              count += counters[i];
          }
          if(count >= limit){
              return false;
          }else{
              counters[index] ++;
              return true;
          }
      }
  
      private synchronized void slideWindow(long windowsNum){
          if(windowsNum == 0)
              return;
          long slideNum = Math.min(windowsNum,splitNum);
          for(int i = 0;i < slideNum;i ++){
              index = (index + 1) % splitNum;
              counters[index] = 0;
          }
          startTime = startTime + windowsNum * (windowSize / splitNum);//更新滑动窗口时间
      }
  
      //测试
      public static void main(String[] args) throws InterruptedException {
          //每秒20个请求
          int limit = 20;
          CounterSildeWindowLimiter counterSildeWindowLimiter = new CounterSildeWindowLimiter(1000,limit,10);
          int count = 0;
  
          Thread.sleep(3000);
          //计数器滑动窗口算法模拟100组间隔30ms的50次请求
          System.out.println("计数器滑动窗口算法测试开始");
          System.out.println("开始模拟100组间隔150ms的50次请求");
          int faliCount = 0;
          for(int j = 0;j < 100;j ++){
              count = 0;
              for(int i = 0;i < 50;i ++){
                  if(counterSildeWindowLimiter.tryAcquire()){
                      count ++;
                  }
              }
              Thread.sleep(150);
              //模拟50次请求，看多少能通过
              for(int i = 0;i < 50;i ++){
                  if(counterSildeWindowLimiter.tryAcquire()){
                      count ++;
                  }
              }
              if(count > limit){
                  System.out.println("时间窗口内放过的请求超过阈值，放过的请求数" + count + ",限流：" + limit);
                  faliCount ++;
              }
              Thread.sleep((int)(Math.random() * 100));
          }
          System.out.println("计数器滑动窗口算法测试结束，100组间隔150ms的50次请求模拟完成，限流失败组数：" + faliCount);
          System.out.println("===========================================================================================");
  
  
          //计数器固定窗口算法模拟100组间隔30ms的50次请求
          System.out.println("计数器固定窗口算法测试开始");
          //模拟100组间隔30ms的50次请求
          CounterLimiter counterLimiter = new CounterLimiter(1000,limit);
          System.out.println("开始模拟100组间隔150ms的50次请求");
          faliCount = 0;
          for(int j = 0;j < 100;j ++){
              count = 0;
              for(int i = 0;i < 50;i ++){
                  if(counterLimiter.tryAcquire()){
                      count ++;
                  }
              }
              Thread.sleep(150);
              //模拟50次请求，看多少能通过
              for(int i = 0;i < 50;i ++){
                  if(counterLimiter.tryAcquire()){
                      count ++;
                  }
              }
              if(count > limit){
                  System.out.println("时间窗口内放过的请求超过阈值，放过的请求数" + count + ",限流：" + limit);
                  faliCount ++;
              }
              Thread.sleep((int)(Math.random() * 100));
          }
          System.out.println("计数器滑动窗口算法测试结束，100组间隔150ms的50次请求模拟完成，限流失败组数：" + faliCount);
      }
  }
  
  

  测试时，取滑动窗口大小为1000/10=100ms，然后模拟100组间隔150ms的50次请求，计数器滑动窗口算法与计数器固定窗口算法进行对别，可以看到如下结果：

  

  固定窗口算法在窗口切换时产生了两倍于阈值流量请求的问题，而滑动窗口算法避免了这个问题。

• 您还可以看一下 朱有鹏老师的内存这个大话题-4.1.C语言专题第一部分课程中的 4.1.9、复杂数据结构小节, 巩固相关知识点