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

（2）由关键字返回倒排拉链

含义：倒排外部实现，根据'关键字'返回对应的 ID，即返回对应的 vector 成员。 解释：每个关键词涉及到的 ID 肯定不止一个，所以需要 vector 代表一个关键词涉及到的所有文档。

Stock_Inverted* GetInverted_index(const std::string word) {
    auto it = Inverted.find(word);
    if(it == Inverted.end()) {
        std::cerr << "GetInverted_index is errno" << std::endl;
        return {};
    }
    return &it->second;
}

（3）说明

现在我们已经有了给外部的接口：由 ID 返回文档内容、由关键词返回文档 ID。 那么接下来就是填变量、建立索引关系：

//正排存储
std::vector<Forwardindex> Forward;
typedef std::vector<Invertedindex> Stock_Inverted;
//倒排存储
std::unordered_map<std::string, Stock_Inverted> Inverted;

（4）建立索引

原理：利用上一篇文章完成的数据清洗，最终每个.html 文档内容都被输出到了 data_clean.txt 中。 我们先利用 getline 按行读取（也就是按单个文档读取，因为 data_clean.txt 中也是按行写的）到 line 变量里面，这样就拿到了单个文档的内容，因此 while 就是拿取 data_clean.txt 的全部文档内容！ 建索引也就是同时建立正排和倒排的内容，也就是填 vector 和 Unordered_map 的操作！

bool Buildindex(const std::string &input) {
    std::ifstream in(input, std::ios::in | std::ios::binary);
    if(!in.is_open()) {
        std::cerr << "Buildindex is errno" << std::endl;
        return false;
    }
    std::string line;
    while(std::getline(in, line)) {
        Forwardindex *doc = Build_Forward_Index(line);
        printf("正在建立索引:%lld\ntitle:%s\nchain:%s\n", doc->doc_id, doc->title.c_str(), doc->chain.c_str());
        if(doc == nullptr) continue;
        Build_Inverted_Index(*doc);
    }
    return true;
}

（5）建立正排索引

思路：首先我们拿到了单个文档的内容，也就是 line（string）变量，然后对这个内容进行解析，提取出标题、内容、URL（每个 line 变量都是：标题 | 内容 | URL 的格式，分割即可！）然后填入到 vector 里面，该文档的 ID 刚好就是 vector 的下标。

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 = "空";

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

    index->doc_id = Forward.size();
    Forward.push_back(*index);
    return index;
}

typedef struct Forward_index {
    std::string title;
    std::string source;
    std::string chain;
    uint64_t doc_id;
} Forwardindex;

（6）建立倒排索引

bool Build_Inverted_Index(const Forwardindex& doc) {
    JiebaUtil jieba;
    std::vector<std::string> S;
    S = jieba.Tokenize(doc.title);
    struct culculate {
        int title_size=0;
        int source_size=0;
    };
    std::unordered_map<std::string, culculate> V;
    for(auto e : S) {
        (V[e].title_size)++;
    }
    S.clear();
    S = jieba.Tokenize(doc.source);
    for(auto e : S) {
        (V[e].source_size)++;
    }
    for(auto it : V) {
        Invertedindex index_t;
        index_t.word = it.first;
        index_t.doc_id = doc.doc_id;
        index_t.weight = ((it.second.title_size)*2 + (it.second.source_size)*1);
        Inverted[it.first].push_back(std::move(index_t));
    }
    return true;
}

【四】单例模式

单例模式：只允许创建一个 Index 对象，后面只能由 index 指针调用该对象。

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
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;
    }
    ......
};

Index* Index::instance = nullptr;