原创：数据挖掘十大算法之4——Apriori算法+编码

1. 基本Apriori算法：

主要思想是：连接步+Apriori性质

• 统计单项在的支持度，再利用连接步生成2项；
• 对2项采取Apriori性质剪枝，得到可能的2项；
• 再将2项的再原始中统计得出其支持度，并减去达不到支持度的项。
• 按照上面步骤重复，直到不能产生新的更多项。

因为从网上找的程序都不太好调试，特贴出自己编写的程序，当然这个针对的是固定的一个对象，通过修改能达到同样的目的，欢迎指出错误！

主程序：

#include <iostream>
#include <string>
#include <math.h>
#include "Apri.h"
int main(){
    Apri aa(2);
    First_Iteam First_set[9];
    First_set[0].name = "T100";
    First_set[0].Iteams[0] = "I1";
    First_set[0].Iteams[1] = "I2";
    First_set[0].Iteams[2] = "I5";
    
    First_set[1].name = "T200";
    First_set[1].Iteams[0] = "I2";
    First_set[1].Iteams[1] = "I4";
    
    First_set[2].name = "T300";
    First_set[2].Iteams[0] = "I2";
    First_set[2].Iteams[1] = "I3";
    
    First_set[3].name = "T400";
    First_set[3].Iteams[0] = "I1";
    First_set[3].Iteams[1] = "I2";
    First_set[3].Iteams[2] = "I4";
    
    First_set[4].name = "T500";
    First_set[4].Iteams[0] = "I1";
    First_set[4].Iteams[1] = "I3";
    
    First_set[5].name = "T600";
    First_set[5].Iteams[0] = "I2";
    First_set[5].Iteams[1] = "I3";
    
    First_set[6].name = "T700";
    First_set[6].Iteams[0] = "I1";
    First_set[6].Iteams[1] = "I3";
    
    First_set[7].name = "T800";
    First_set[7].Iteams[0] = "I1";
    First_set[7].Iteams[1] = "I2";
    First_set[7].Iteams[2] = "I3";
    First_set[7].Iteams[3] = "I5";
    
    First_set[8].name = "T900";
    First_set[8].Iteams[0] = "I1";
    First_set[8].Iteams[1] = "I2";
    First_set[8].Iteams[2] = "I3";
    
    aa.setFirstSet(First_set);
    aa.Find_frequent_1_itemsets();
    
    
    
    aa.print();
    aa.apriori_gen();
    
    cin.get();
    return 0;   
}

 Apriori类

.h文件：

#include <iostream>
#include <string>
using namespace std;

struct First_Iteam{
       string name;
       string Iteams[5];
       };
       
struct Ci{
       string Items[5];
       int confident;
       };
        
class Apri{
private:
        First_Iteam First_set[9];//存放事物，相当于从数据库中读取的信息,固定为9 
        Ci Ck_Items[100];//计算的K-1的统计信息 
        Ci Cl_Items[100];//新计算的第k个统计信息 
        int Items_k;//k-1的统计信息的数目 
        int Items_l;//k个统计信息的数目 
        int Gen;//现在的代数，开始值为1 
        int min_sup;//最小支持度 
        
public:
       Apri(int);
       void print();
       void setFirstSet(First_Iteam*);
       void Find_frequent_1_itemsets();//查找第一代的数据及其信息
       void Find_ck(string item);//查找是否在K-1中存在此对象
       void apriori_gen();//连接步，将K-1中的数据连接成K的数据 
       bool Apriori_check(Ci);//在K-1中检查一个k-1的字符串是否达到了min_sup,或者是否存在这样的K-1 
       bool Ci_Equal(Ci,Ci);//判断两个串是否相等 
       int ContainCi(Ci);//判断在原集合中对Ci的支持度 
        
};

 .cpp文件：

#include "Apri.h"
Apri::Apri(int a){
    min_sup = a; 
}
void Apri::print(){
     cout << "原始项目集:" << endl; 
     for(int i = 0; i < 9; i++)
     {
         cout << First_set[i].name << ": ";
         for( int j = 0; j < 5; j++)
             if(First_set[i].Iteams[j] != "")
                 cout << First_set[i].Iteams[j] << " ";
         cout << endl;
     }
}
     
     
void Apri::setFirstSet(First_Iteam a[]){
     for(int i = 0; i < 9; i++)
             First_set[i] = a[i];
}
void Apri::Find_frequent_1_itemsets(){
     Gen = 1;
     Items_k = 0;
     for(int i = 0; i < 9; i++)
     {
         int j = 0;
         while(First_set[i].Iteams[j] != ""){
             Find_ck(First_set[i].Iteams[j]);
             j++;
         }
     }
}
//查找是否在第一次中存在这样的项，并统计信息,
//在统计信息时要做到判断准确，不能失误。 
void Apri::Find_ck(string item){
     int i;
     bool isbreak = false;
     for(i = 0; i < Items_k; i++)
         if(item == Ck_Items[i].Items[0])
         {
             isbreak =!isbreak;
             break;
         }
     if(isbreak)
         Ck_Items[i].confident++;
     else
     {
         Ck_Items[i].Items[0] = item;
         Ck_Items[i].confident = 1;
         Items_k++;
     }
}
void Apri::apriori_gen(){
    while(Items_k != 0)
    {
         cout << "-----------------" << "L" << Gen << "------------------" << endl;
         for(int i = 0; i < Items_k; i++)
         {
             for(int j = 0; j < 5; j++)
                 if(Ck_Items[i].Items[j] != "")
                     cout << Ck_Items[i].Items[j] <<" ";
             cout << Ck_Items[i].confident<< endl; 
         }           
               
    
         Items_l = 0;
         for(int i = 0; i < Items_k-1; i++)
         {
             for(int j = i+1; j < Items_k; j++)
             {
                 bool isLink = true;
                 //判断是否能够连接,前面k-2个都相同，但是K-1是不同的 
                 for(int m = 0; m < Gen-1; m++)
                 {
                     if(Ck_Items[i].Items[m] != Ck_Items[j].Items[m])
                     {
                         isLink = false;   
                         break;
                     }                  
                 }
                 if(isLink)
                 {
                     if(Ck_Items[i].Items[Gen-1] != Ck_Items[j].Items[Gen-1])
                     //连接条件成立，进行连接； 
                     {
                         Ci newItem;//生成新连接后得到的串 
                         for(int n = 0; n < Gen; n++)
                             newItem.Items[n] = Ck_Items[i].Items[n];
                         newItem.Items[Gen] = Ck_Items[j].Items[Gen-1]; 
                         //对新生成的串进行数据Apriori剪枝，判断是否合法
                         Ci AllItem;//生成k的所有的k-1子串，并进行检查 
                         bool ThroughApriori = true;//是否通过Apriori检查 
                         for(int g = 0; g <= Gen; g++)
                         {
                              int start = 0;
                              for(int h=0; h <= Gen; h++)
                              {
                                   if(h != g)
                                   {
                                        AllItem.Items[start] = newItem.Items[h]; 
                                        start++;
                                   }      
                              }        
                              //对K-1的子串检查是否达到min_sup
                              if(!Apriori_check(AllItem))
                              {
                                  ThroughApriori = false;
                                  break;                           
                              }
                         } 
                         if(ThroughApriori)//通过了Apriori性质检查，将此条加入到K中 
                         {
                              Cl_Items[Items_l] = newItem;
                              Cl_Items[Items_l].confident = 0;
                              Items_l++;                     
                         } 
                     }
                 }
             } 
         }
         Gen++;
         //接下来处理L的数据的支持度,数据存放在Cl_Items中 
         for(int i = 0; i < Items_l; i++)
         {
             Cl_Items[i].confident =  ContainCi(Cl_Items[i]);
         }
         
         //剪去小于最小支持度的并将CL_Items中的数据转移到Ck_Items中 
         for(int m = 0; m < Items_k; m++)
         {
              for(int j = 0; j < 5; j++)
                  Ck_Items[m].Items[j] = "";
              Ck_Items[m].confident = 0;             
         }
         int new_Items_l = 0;
         for(int i = 0; i < Items_l; i++)
         {
              if(Cl_Items[i].confident >= min_sup)
              { 
                  for(int j = 0; j < 5; j++)
                      Ck_Items[new_Items_l].Items[j] = Cl_Items[i].Items[j];
                  Ck_Items[new_Items_l].confident = Cl_Items[i].confident;
                  new_Items_l++;
              } 
         }
         Items_k = new_Items_l;
         Items_l = 0;
    }  
} 
//当检查时不存在这样的K-1或者存在相等的K-1但是支持度小于min_sup则返回falsse 
bool Apri::Apriori_check(Ci OldCi){
     bool pass = false;
     for(int i = 0; i < Items_k; i++)
     {
         /*if(Ci_Equal(OldCi,Ck_Items[i] && Ck_Items[i].confident < min_sup)
         {
             pass = false;
             break;
         } 
         */
         if(Ci_Equal(OldCi,Ck_Items[i])) 
         {
             pass = true;
             break;
         } 
     }
     return pass;
} 
//判断该两个Ci是否相等 
bool Apri::Ci_Equal(Ci a,Ci b){
    bool isequal  = false;
    int num_a = 0,num_b = 0; 
    while(a.Items[num_a] != "")
        num_a++;
    while(b.Items[num_b] != "")
        num_b++;
    if(num_a != num_b)
        return false;
        
    for(int i = 0;i < Gen; i++)
    {
        isequal = false;
        for(int j = 0; j < Gen; j++)
            if(a.Items[i] == b.Items[j])
            {
                isequal = true;
                break;
            }
        if(!isequal)
            break;                
    }
    return isequal;
}
int Apri::ContainCi(Ci NewCi){
    int num_new = 0, num_item, num_contain = 0; 
    while(NewCi.Items[num_new] != "")
        num_new++;
    bool isequal  = false;
    for(int i = 0; i < 9; i++)
    {
         num_item = 0;          
         while(First_set[i].Iteams[num_item] != "")
             num_item++;
         if(num_new > num_item)
             continue;
         else
         {
             for(int j = 0; j < num_new; j++)
             {
                 isequal = false;
                 for(int m = 0; m < num_item; m++)
                 {
                      if(NewCi.Items[j] == First_set[i].Iteams[m])
                      {
                          isequal = true;
                          break;                  
                      }
                 }
                 if(!isequal)
                     break;     
             }
             if(isequal)
                 num_contain++;
         } 
    }
    return num_contain;
}

宿舍