c语言实现贝叶斯算法

贝叶斯算法是一种基于概率的分类算法，可以用于文本分类、垃圾邮件过滤等场景。在C语言中，可以通过以下步骤实现贝叶斯分类算法：

1. 准备训练数据集，包括训练文本和对应的分类标签。
2. 统计每个分类中的单词出现频率，并计算每个单词在每个分类中的出现概率。
3. 对于待分类文本，将其分词并计算每个单词在各个分类中的概率。
4. 根据贝叶斯公式计算该文本属于各个分类的概率，选择概率最大的分类作为预测结果。

下面是一个简单的C语言实现：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_DOC_LEN 1000  //最大文本长度
#define MAX_WORD_CNT 100  //最大单词数
#define MAX_CLASS_CNT 10  //最大分类数

//定义单词结构体
typedef struct{
    char word[20];  //单词字符串
    int freq;       //出现次数
    float prob;     //出现概率
}Word;

//定义分类结构体
typedef struct{
    char name[20];  //分类名称
    int cnt;        //单词数
    Word words[MAX_WORD_CNT];  //单词列表
}Class;

//全局变量，存储所有分类
Class classes[MAX_CLASS_CNT];
int class_cnt = 0;

//统计单词出现次数
void count_words(char *doc, int doc_len, Class *c){
    char *p = doc;
    char word[20] = {0};
    int i, j;

    //遍历文本中的每个字符
    for(i=0; i<doc_len; i++){
        if(isalpha(p[i])){  //如果是字母
            //将字母转换为小写
            word[j++] = tolower(p[i]);
        }
        else if(j>0){  //如果不是字母但之前有单词
            //将单词加入分类中
            word[j] = '\0';
            for(j=0; j<c->cnt; j++){
                if(strcmp(c->words[j].word, word)==0){
                    c->words[j].freq++;
                    break;
                }
            }
            if(j==c->cnt){  //如果单词不在分类中
                strcpy(c->words[j].word, word);
                c->words[j].freq = 1;
                c->cnt++;
            }
            j = 0;
        }
    }
}

//计算单词出现概率
void calc_probs(Class *c){
    int i;
    int total_words = 0;

    //统计分类中的总单词数
    for(i=0; i<c->cnt; i++){
        total_words += c->words[i].freq;
    }

    //计算每个单词的出现概率
    for(i=0; i<c->cnt; i++){
        c->words[i].prob = (float)c->words[i].freq / total_words;
    }
}

//训练分类器
void train(char *doc, int doc_len, char *class_name){
    int i;
    Class *c = NULL;

    //查找分类
    for(i=0; i<class_cnt; i++){
        if(strcmp(classes[i].name, class_name)==0){
            c = &classes[i];
            break;
        }
    }

    //如果分类不存在则新建一个分类
    if(!c){
        strcpy(classes[class_cnt].name, class_name);
        classes[class_cnt].cnt = 0;
        c = &classes[class_cnt];
        class_cnt++;
    }

    //统计单词出现次数
    count_words(doc, doc_len, c);

    //计算单词出现概率
    calc_probs(c);
}

//计算文本在分类中的概率
float calc_doc_prob(char *doc, int doc_len, Class *c){
    char *p = doc;
    char word[20] = {0};
    int i, j;
    float prob = 1.0;

    //遍历文本中的每个字符
    for(i=0; i<doc_len; i++){
        if(isalpha(p[i])){  //如果是字母
            //将字母转换为小写
            word[j++] = tolower(p[i]);
        }
        else if(j>0){  //如果不是字母但之前有单词
            //查找单词在分类中的出现概率
            word[j] = '\0';
            for(j=0; j<c->cnt; j++){
                if(strcmp(c->words[j].word, word)==0){
                    prob *= c->words[j].prob;
                    break;
                }
            }
            j = 0;
        }
    }

    return prob;
}

//预测文本所属分类
char *predict(char *doc, int doc_len){
    int i;
    float max_prob = 0.0;
    char *class_name = NULL;

    //遍历所有分类，选择概率最大的分类
    for(i=0; i<class_cnt; i++){
        float prob = calc_doc_prob(doc, doc_len, &classes[i]);
        if(prob > max_prob){
            max_prob = prob;
            class_name = classes[i].name;
        }
    }

    return class_name;
}

int main(){
    char doc[MAX_DOC_LEN] = "this is a test document";
    char class_name[20] = "test";

    //训练分类器
    train(doc, strlen(doc), class_name);

    //预测文本所属分类
    char *pred_class = predict(doc, strlen(doc));
    printf("Predicted class: %s\n", pred_class);

    return 0;
}

以上代码只是一个简单的示例，实际应用中还需要考虑词频平滑、停用词过滤等问题，以提高分类效果。