数据挖掘apriori算法c++

Apriori算法是一种经典的频繁项集挖掘算法，主要用于发现数据集中频繁出现的项集。下面是Apriori算法的C++实现：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

//定义项集
typedef vector<int> Item;
//定义事务
typedef vector<Item> Transaction;
//定义频繁项集
typedef vector<Item> FrequentSet;

class Apriori
{
public:
    //构造函数
    Apriori(Transaction t, int s, float c):m_transactions(t), m_minSupport(s), m_confidence(c) {}
    //执行算法
    void Run()
    {
        //初始化候选项集
        InitCandidateSet();
        //迭代求解频繁项集
        while (m_candidateSet.size() > 0)
        {
            //扫描事务集，统计候选项集的支持度
            CountCandidateSet();
            //从候选项集中选择频繁项集
            SelectFrequentSet();
            //生成新的候选项集
            GenerateCandidateSet();
        }
    }
    //获取频繁项集
    FrequentSet GetFrequentSet()
    {
        return m_frequentSet;
    }
private:
    //扫描事务集，统计候选项集的支持度
    void CountCandidateSet()
    {
        m_supportCount.clear();
        for (int i = 0; i < m_candidateSet.size(); i++)
        {
            Item& item = m_candidateSet[i];
            int count = 0;
            for (int j = 0; j < m_transactions.size(); j++)
            {
                if (IsSubset(item, m_transactions[j]))
                {
                    count++;
                }
            }
            m_supportCount.push_back(count);
        }
    }
    //从候选项集中选择频繁项集
    void SelectFrequentSet()
    {
        m_frequentSet.clear();
        for (int i = 0; i < m_candidateSet.size(); i++)
        {
            int count = m_supportCount[i];
            if (count >= m_minSupport)
            {
                m_frequentSet.push_back(m_candidateSet[i]);
            }
        }
    }
    //生成新的候选项集
    void GenerateCandidateSet()
    {
        m_candidateSet.clear();
        for (int i = 0; i < m_frequentSet.size(); i++)
        {
            for (int j = i + 1; j < m_frequentSet.size(); j++)
            {
                Item newItem = MergeItem(m_frequentSet[i], m_frequentSet[j]);
                if (newItem.size() > 0 && !IsItemExist(newItem, m_candidateSet))
                {
                    m_candidateSet.push_back(newItem);
                }
            }
        }
    }
    //初始化候选项集
    void InitCandidateSet()
    {
        m_candidateSet.clear();
        for (int i = 0; i < m_transactions.size(); i++)
        {
            for (int j = 0; j < m_transactions[i].size(); j++)
            {
                Item item;
                item.push_back(m_transactions[i][j]);
                if (!IsItemExist(item, m_candidateSet))
                {
                    m_candidateSet.push_back(item);
                }
            }
        }
    }
    //判断是否为子集
    bool IsSubset(Item a, Item b)
    {
        for (int i = 0; i < a.size(); i++)
        {
            bool exist = false;
            for (int j = 0; j < b.size(); j++)
            {
                if (a[i] == b[j])
                {
                    exist = true;
                    break;
                }
            }
            if (!exist)
            {
                return false;
            }
        }
        return true;
    }
    //判断项集是否存在
    bool IsItemExist(Item item, vector<Item> itemList)
    {
        for (int i = 0; i < itemList.size(); i++)
        {
            if (itemList[i] == item)
            {
                return true;
            }
        }
        return false;
    }
    //合并两个项
    Item MergeItem(Item a, Item b)
    {
        Item item;
        for (int i = 0; i < a.size(); i++)
        {
            item.push_back(a[i]);
        }
        for (int i = 0; i < b.size(); i++)
        {
            bool exist = false;
            for (int j = 0; j < a.size(); j++)
            {
                if (b[i] == a[j])
                {
                    exist = true;
                    break;
                }
            }
            if (!exist)
            {
                item.push_back(b[i]);
            }
        }
        return item;
    }
private:
    Transaction m_transactions;     //事务集
    int m_minSupport;               //最小支持度
    float m_confidence;             //置信度
    vector<Item> m_candidateSet;   //候选项集
    vector<int> m_supportCount;     //支持度计数
    FrequentSet m_frequentSet;       //频繁项集
};

int main()
{
    //定义事务集
    Transaction transactions;
    Item t1 = { 1, 2, 3, 4 };
    Item t2 = { 1, 2, 4 };
    Item t3 = { 1, 2 };
    Item t4 = { 2, 3, 4 };
    Item t5 = { 2, 3 };
    Item t6 = { 3, 4 };
    transactions.push_back(t1);
    transactions.push_back(t2);
    transactions.push_back(t3);
    transactions.push_back(t4);
    transactions.push_back(t5);
    transactions.push_back(t6);

    //定义最小支持度和置信度
    int minSupport = 2;
    float confidence = 0.5;

    //执行Apriori算法
    Apriori apriori(transactions, minSupport, confidence);
    apriori.Run();

    //获取频繁项集
    FrequentSet frequentSet = apriori.GetFrequentSet();

    //输出频繁项集
    for (int i = 0; i < frequentSet.size(); i++)
    {
        Item& item = frequentSet[i];
        for (int j = 0; j < item.size(); j++)
        {
            cout << item[j] << " ";
        }
        cout << endl;
    }

    return 0;
}

以上就是一个简单的Apriori算法的C++实现，可以用来挖掘数据集中的频繁项集。