C++ 轻量级搜索引擎实战：正/倒排索引构建详解 | 极客日志

C++AI算法

C++ 轻量级搜索引擎实战：正/倒排索引构建详解

基于 C++ 实现的轻量级搜索引擎核心索引模块，涵盖正排与倒排数据结构设计、CppJieba 分词集成及单例模式应用。通过解析清洗后的文档数据，建立关键词到文档 ID 的映射关系，并支持按 ID 检索原文内容。代码展示了文件读取、内存管理及线程安全实例化的具体实现细节。

baireiraku发布于 2026/3/280 浏览

C++ 轻量级搜索引擎实战：正/倒排索引构建详解

在构建搜索引擎时，倒排索引是查询性能的关键。我们基于 C++11 标准，利用 STL 和 Boost 库来实现从文档清洗到索引构建的完整流程。这里主要关注如何高效地存储和检索数据。

首先定义数据结构。正排索引用于通过文档 ID 快速定位原始内容，倒排索引则负责将关键词映射到相关的文档列表。

// 正排结构体：存储文档元数据
typedef struct Forward_index {
    std::string title;      // 标题
    std::string source;     // 正文内容
    std::string chain;      // URL 链接
    uint64_t doc_id;        // 文档唯一标识
} Forwardindex;

// 倒排结构体：存储关键词权重信息
typedef struct Inverted_index {
    int doc_id;             // 关联的正排 ID
    std::string word;       // 关键词
    int weight;             // 权重值
} Invertedindex;

正排部分直接使用 std::vector，下标即 ID；倒排部分使用 std::unordered_map 以 O(1) 复杂度查找关键词对应的文档链表。

// 全局索引容器
std::vector<Forwardindex> Forward;
typedef std::vector<Invertedindex> Stock_Inverted;
std::unordered_map<std::string, Stock_Inverted> Inverted;

接下来是具体的函数实现。为了获取外部可访问的接口，我们需要封装两个核心方法：根据 ID 取文档，以及根据关键词取倒排链表。

// 根据 ID 获取文档内容
Forwardindex* GetForward_index(const long long& id) {
    if(id >= Forward.size()) {
        std::cerr << "Invalid document ID" << std::endl;
        return nullptr;
    }
    return &Forward[id];
}

// 根据关键字获取倒排拉链
Stock_Inverted* GetInverted_index {
     it = Inverted.(word);
    (it == Inverted.()) {
        std::cerr <<  << std::endl;
         ;
    }
     &it->second;
}

bool Buildindex(const std::string &input) {
    std::ifstream in(input, std::ios::in | std::ios::binary);
    if(!in.is_open()) {
        std::cerr << "Failed to open file" << std::endl;
        return false;
    }

    std::string line;
    while(std::getline(in, line)) {
        // 解析单条记录并构建正排
        Forwardindex* doc = Build_Forward_Index(line);
        if(doc == nullptr) continue;

        // 基于正排数据构建倒排
        Build_Inverted_Index(*doc);
    }
    return true;
}

Forwardindex* Build_Forward_Index(const std::string& line) {
    Forwardindex* index = new Forwardindex();
    
    // 提取标题
    size_t set_pos1 = line.find('\3');
    if(set_pos1 == std::string::npos) { delete index; return nullptr; }
    index->title = line.substr(0, set_pos1);
    if(index->title.empty()) index->title = "空";

    // 提取内容
    size_t set_pos2 = line.find('\3', set_pos1 + 1);
    if(set_pos2 == std::string::npos) { delete index; return nullptr; }
    index->source = line.substr(set_pos1 + 1, set_pos2 - (set_pos1 + 1));
    if(index->source.empty()) index->source = "空";

    // 提取 URL
    index->chain = line.substr(set_pos2 + 1);
    if(index->chain.empty()) index->chain = "空";

    // 分配 ID 并入库
    index->doc_id = Forward.size();
    Forward.push_back(*index);
    return index;
}

bool Build_Inverted_Index(const Forwardindex& doc) {
    JiebaUtil jieba;
    std::vector<std::string> tokens;
    struct CalculateInfo {
        int title_count = 0;
        int source_count = 0;
    };
    std::unordered_map<std::string, CalculateInfo> stats;

    // 统计标题分词
    tokens = jieba.Tokenize(doc.title);
    for(auto& e : tokens) stats[e].title_count++;

    // 统计正文分词
    tokens.clear();
    tokens = jieba.Tokenize(doc.source);
    for(auto& e : tokens) stats[e].source_count++;

    // 写入倒排索引
    for(auto& it : stats) {
        Invertedindex idx;
        idx.word = it.first;
        idx.doc_id = doc.doc_id;
        // 权重计算：标题权重 x2 + 正文权重 x1
        idx.weight = (it.second.title_count * 2) + (it.second.source_count * 1);
        Inverted[it.first].push_back(std::move(idx));
    }
    return true;
}

class Index {
public:
    typedef std::vector<Invertedindex> Stock_Inverted;
    Index(const Index&) = delete;
    Index& operator=(const Index&) = delete;

    static Index* handle() {
        if(instance == nullptr) {
            pthread_mutex_lock(&mutex);
            if(instance == nullptr) {
                instance = new Index;
            }
            pthread_mutex_unlock(&mutex);
        }
        return instance;
    }

private:
    static Index* instance;
    static pthread_mutex_t mutex;
};

Index* Index::instance = nullptr;
pthread_mutex_t Index::mutex = PTHREAD_MUTEX_INITIALIZER;