倒排索引和正向索引区别以及实现原理

原创 于 2025-10-27 11:29:31 发布 · 678 阅读 · 20 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言 #c++

一、概念区别

1. 正向索引（Forward Index）

定义：
正向索引是以“文档为中心”，记录每个文档中包含哪些词，以及这些词在文档中的位置等信息。

结构示例：

文档ID内容词项列表
1我爱自然语言处理[我, 爱, 自然, 语言, 处理]
2语言处理很有趣[语言, 处理, 很, 有趣]

应用场景：
正向索引常用于搜索引擎的文档存储、展示、排序等场景。

2. 倒排索引（Inverted Index）

定义：
倒排索引是以“词项为中心”，记录每个词项出现在哪些文档中，以及在文档中的位置等信息。

结构示例：

词项文档列表
我[1]
爱[1]
自然[1]
语言[1, 2]
处理[1, 2]
很[2]
有趣[2]

应用场景：
倒排索引是搜索引擎、信息检索系统的核心，用于高效地查找包含某个词项的所有文档。

二、实现原理

1. 正向索引实现原理

流程：

  1. 分词：对每个文档内容进行分词处理，得到词项列表。
  2. 建立索引：将文档ID与词项列表进行关联，通常存储为如下结构： 
    {
  文档ID: [词项1, 词项2, ...]
}
  3. 存储：可以使用数据库、键值对存储系统或文件系统来存储。

扩展：
可以在每个词项后面加上位置信息、词频等，用于后续相关性计算。

2. 倒排索引实现原理

流程：

  1. 分词：对所有文档进行分词处理，得到词项与文档的对应关系。
  2. 构建倒排列表：对每个词项，建立一个文档列表，记录该词项出现在哪些文档中。 
    {
  词项: [文档ID1, 文档ID2, ...]
}
  3. 优化：
    • 可以在文档ID后加上词频、位置等信息。
    • 对文档列表进行压缩（如位图、跳表等）以节省存储空间。
  4. 存储：通常使用高效的数据结构（如哈希表、B树、倒排文件）存储。

三、区别总结

对比项正向索引倒排索引
关注点文档 -> 词项词项 -> 文档
查询效率适合查找文档内容适合查找包含某词的所有文档
应用场景文档展示、排序、聚合搜索引擎查询、信息检索
存储结构文档ID为主键，值为词项列表词项为主键，值为文档ID列表
构建流程按文档分词，存储词项按词项聚合，存储文档列表

四、举例说明

假设有两个文档：

  • 文档1：“我喜欢学习”
  • 文档2：“学习使人进步”

正向索引：

文档ID词项列表
1[我, 喜欢, 学习]
2[学习, 使, 人, 进步]

倒排索引：

词项文档列表
我[1]
喜欢[1]
学习[1, 2]
使[2]
人[2]
进步[2]

五、代码实现简述（Python伪代码）

正向索引

forward_index = {}
for doc_id, content in enumerate(docs):
    tokens = tokenize(content)
    forward_index[doc_id] = tokens

倒排索引

inverted_index = {}
for doc_id, content in enumerate(docs):
    tokens = tokenize(content)
    for token in tokens:
        if token not in inverted_index:
            inverted_index[token] = []
        inverted_index[token].append(doc_id)

六、总结

  • 正向索引：文档到词项的映射，便于文档内容管理。
  • 倒排索引：词项到文档的映射，便于快速查找包含某词的文档，是搜索引擎的核心。

七、完整代码实现

1、准备工作

假设我们的文档集合如下：

std::vector<std::string> docs = {
    "我 爱 自然语言处理",
    "语言处理 很 有趣",
    "自然语言 是 人工智能 的基础"
};

我们将以空格分词（实际应用中可用更复杂的分词算法）。

2、分词函数

#include <vector>
#include <string>
#include <sstream>

std::vector<std::string> tokenize(const std::string& text) {
    std::vector<std::string> tokens;
    std::istringstream iss(text);
    std::string token;
    while (iss >> token) {
        tokens.push_back(token);
    }
    return tokens;
}

3、正向索引实现

正向索引结构：std::unordered_map<int, std::vector<std::string>>
（文档ID -> 词项列表）

#include <unordered_map>
#include <iostream>

void build_forward_index(const std::vector<std::string>& docs,
                         std::unordered_map<int, std::vector<std::string>>& forward_index) {
    for (size_t doc_id = 0; doc_id < docs.size(); ++doc_id) {
        forward_index[doc_id] = tokenize(docs[doc_id]);
    }
}

// 查询文档内容
void print_doc_tokens(int doc_id, const std::unordered_map<int, std::vector<std::string>>& forward_index) {
    auto it = forward_index.find(doc_id);
    if (it != forward_index.end()) {
        std::cout << "Doc " << doc_id << ": ";
        for (const auto& token : it->second) {
            std::cout << token << " ";
        }
        std::cout << std::endl;
    } else {
        std::cout << "Doc not found." << std::endl;
    }
}

4、倒排索引实现

倒排索引结构：std::unordered_map<std::string, std::vector<int>>
（词项 -> 文档ID列表）

void build_inverted_index(const std::vector<std::string>& docs,
                          std::unordered_map<std::string, std::vector<int>>& inverted_index) {
    for (size_t doc_id = 0; doc_id < docs.size(); ++doc_id) {
        auto tokens = tokenize(docs[doc_id]);
        for (const auto& token : tokens) {
            inverted_index[token].push_back(doc_id);
        }
    }
}

// 查询包含某词的文档
void print_docs_for_token(const std::string& token, const std::unordered_map<std::string, std::vector<int>>& inverted_index) {
    auto it = inverted_index.find(token);
    if (it != inverted_index.end()) {
        std::cout << "Token \"" << token << "\" in docs: ";
        for (int doc_id : it->second) {
            std::cout << doc_id << " ";
        }
        std::cout << std::endl;
    } else {
        std::cout << "Token not found." << std::endl;
    }
}

5、完整可运行示例

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <sstream>

// 分词
std::vector<std::string> tokenize(const std::string& text) {
    std::vector<std::string> tokens;
    std::istringstream iss(text);
    std::string token;
    while (iss >> token) {
        tokens.push_back(token);
    }
    return tokens;
}

// 正向索引
void build_forward_index(const std::vector<std::string>& docs,
                         std::unordered_map<int, std::vector<std::string>>& forward_index) {
    for (size_t doc_id = 0; doc_id < docs.size(); ++doc_id) {
        forward_index[doc_id] = tokenize(docs[doc_id]);
    }
}

// 倒排索引
void build_inverted_index(const std::vector<std::string>& docs,
                          std::unordered_map<std::string, std::vector<int>>& inverted_index) {
    for (size_t doc_id = 0; doc_id < docs.size(); ++doc_id) {
        auto tokens = tokenize(docs[doc_id]);
        for (const auto& token : tokens) {
            inverted_index[token].push_back(doc_id);
        }
    }
}

// 查询正向索引
void print_doc_tokens(int doc_id, const std::unordered_map<int, std::vector<std::string>>& forward_index) {
    auto it = forward_index.find(doc_id);
    if (it != forward_index.end()) {
        std::cout << "Doc " << doc_id << ": ";
        for (const auto& token : it->second) {
            std::cout << token << " ";
        }
        std::cout << std::endl;
    } else {
        std::cout << "Doc not found." << std::endl;
    }
}

// 查询倒排索引
void print_docs_for_token(const std::string& token, const std::unordered_map<std::string, std::vector<int>>& inverted_index) {
    auto it = inverted_index.find(token);
    if (it != inverted_index.end()) {
        std::cout << "Token \"" << token << "\" in docs: ";
        for (int doc_id : it->second) {
            std::cout << doc_id << " ";
        }
        std::cout << std::endl;
    } else {
        std::cout << "Token not found." << std::endl;
    }
}

int main() {
    std::vector<std::string> docs = {
        "我 爱 自然语言处理",
        "语言处理 很 有趣",
        "自然语言 是 人工智能 的基础"
    };

    // 构建正向索引
    std::unordered_map<int, std::vector<std::string>> forward_index;
    build_forward_index(docs, forward_index);

    // 构建倒排索引
    std::unordered_map<std::string, std::vector<int>> inverted_index;
    build_inverted_index(docs, inverted_index);

    // 查询
    print_doc_tokens(0, forward_index); // 查询文档0的词项
    print_docs_for_token("语言处理", inverted_index); // 查询包含"语言处理"的文档
    print_docs_for_token("自然语言", inverted_index); // 查询包含"自然语言"的文档
    print_docs_for_token("人工智能", inverted_index); // 查询包含"人工智能"的文档

    return 0;
}

6、扩展说明

  1. 词频统计
    倒排索引可以存储词频或位置：
    std::unordered_map<std::string, std::unordered_map<int, int>>
    （词项 -> 文档ID -> 词频）

  2. 分词优化
    实际应用中需用更专业的分词工具（如jieba、THULAC等）。

  3. 索引压缩与优化
    可用位图、跳表等结构优化倒排索引存储与查询效率。

7. 倒排索引扩展：词频统计

倒排索引不仅记录“词项->文档ID列表”，还可以记录每个词项在每个文档中出现的次数（词频）。

数据结构可以定义为：

// 词项 -> (文档ID -> 词频)
std::unordered_map<std::string, std::unordered_map<int, int>> inverted_index_with_freq;

构建带词频的倒排索引


void build_inverted_index_with_freq(
    const std::vector<std::string>& docs,
    std::unordered_map<std::string, std::unordered_map<int, int>>& inverted_index_with_freq) {
    for (size_t doc_id = 0; doc_id < docs.size(); ++doc_id) {
        auto tokens = tokenize(docs[doc_id]);
        for (const auto& token : tokens) {
            inverted_index_with_freq[token][doc_id] += 1;
        }
    }
}

查询某词在各文档中的词频

void print_token_freq(const std::string& token,
    const std::unordered_map<std::string, std::unordered_map<int, int>>& inverted_index_with_freq) {
    auto it = inverted_index_with_freq.find(token);
    if (it != inverted_index_with_freq.end()) {
        std::cout << "Token \"" << token << "\" frequency in docs:\n";
        for (const auto& pair : it->second) {
            std::cout << "  doc " << pair.first << ": " << pair.second << "\n";
        }
    } else {
        std::cout << "Token not found." << std::endl;
    }
}

8. 支持短语搜索

短语搜索，比如“自然语言处理”，需要记录每个词在文档中的位置，并在查询时判断这些词在文档中是否连续出现。

数据结构

// 词项 -> (文档ID -> [位置列表])
std::unordered_map<std::string, std::unordered_map<int, std::vector<int>>> inverted_index_with_pos;

构建带位置信息的倒排索引

void build_inverted_index_with_pos(
    const std::vector<std::string>& docs,
    std::unordered_map<std::string, std::unordered_map<int, std::vector<int>>>& inverted_index_with_pos) {
    for (size_t doc_id = 0; doc_id < docs.size(); ++doc_id) {
        auto tokens = tokenize(docs[doc_id]);
        for (size_t pos = 0; pos < tokens.size(); ++pos) {
            inverted_index_with_pos[tokens[pos]][doc_id].push_back(pos);
        }
    }
}

短语搜索实现（简单版）


// 判断某文档中是否存在短语（tokens顺序连续）
bool phrase_in_doc(const std::vector<std::string>& tokens,
                   const std::vector<std::string>& doc_tokens) {
    if (tokens.size() > doc_tokens.size()) return false;
    for (size_t i = 0; i <= doc_tokens.size() - tokens.size(); ++i) {
        bool match = true;
        for (size_t j = 0; j < tokens.size(); ++j) {
            if (doc_tokens[i + j] != tokens[j]) {
                match = false;
                break;
            }
        }
        if (match) return true;
    }
    return false;
}

// 查询所有包含短语的文档
void search_phrase(const std::string& phrase,
                   const std::vector<std::string>& docs) {
    auto tokens = tokenize(phrase);
    std::cout << "Docs containing phrase \"" << phrase << "\": ";
    for (size_t doc_id = 0; doc_id < docs.size(); ++doc_id) {
        auto doc_tokens = tokenize(docs[doc_id]);
        if (phrase_in_doc(tokens, doc_tokens)) {
            std::cout << doc_id << " ";
        }
    }
    std::cout << std::endl;
}

9. 索引持久化（写入/读取文件）

以词频倒排索引为例，写入和读取可以简单实现为文本格式。

写入倒排索引到文件

#include <fstream>

void save_inverted_index_with_freq(
    const std::unordered_map<std::string, std::unordered_map<int, int>>& inverted_index_with_freq,
    const std::string& filename) {
    std::ofstream ofs(filename);
    for (const auto& token_pair : inverted_index_with_freq) {
        ofs << token_pair.first;
        for (const auto& doc_pair : token_pair.second) {
            ofs << " " << doc_pair.first << ":" << doc_pair.second;
        }
        ofs << "\n";
    }
    ofs.close();
}

从文件读取倒排索引

void load_inverted_index_with_freq(
    std::unordered_map<std::string, std::unordered_map<int, int>>& inverted_index_with_freq,
    const std::string& filename) {
    std::ifstream ifs(filename);
    std::string line;
    while (std::getline(ifs, line)) {
        std::istringstream iss(line);
        std::string token;
        iss >> token;
        std::string doc_freq;
        while (iss >> doc_freq) {
            auto pos = doc_freq.find(':');
            int doc_id = std::stoi(doc_freq.substr(0, pos));
            int freq = std::stoi(doc_freq.substr(pos + 1));
            inverted_index_with_freq[token][doc_id] = freq;
        }
    }
    ifs.close();
}

10. 综合示例

下面是一个包含以上所有功能的主函数片段：

int main() {
    std::vector<std::string> docs = {
        "我 爱 自然语言处理",
        "语言处理 很 有趣",
        "自然语言 是 人工智能 的基础",
        "我 爱 人工智能"
    };

    // 1. 词频倒排索引
    std::unordered_map<std::string, std::unordered_map<int, int>> inverted_index_with_freq;
    build_inverted_index_with_freq(docs, inverted_index_with_freq);
    print_token_freq("人工智能", inverted_index_with_freq);

    // 2. 短语搜索
    search_phrase("我 爱", docs);
    search_phrase("自然语言 处理", docs);
    search_phrase("自然语言 是", docs);

    // 3. 持久化
    save_inverted_index_with_freq(inverted_index_with_freq, "index.txt");
    std::unordered_map<std::string, std::unordered_map<int, int>> loaded_index;
    load_inverted_index_with_freq(loaded_index, "index.txt");
    print_token_freq("人工智能", loaded_index);

    return 0;
}

总结

  • 你可以根据实际需求，扩展索引结构，支持词频、位置、短语搜索等功能。
  • 持久化可用更高效的二进制格式和数据库存储。
  • 实际搜索引擎会有更复杂的优化，如布尔检索、评分排序、分布式存储等。
ElasticSearch - 分布式搜索引擎底层实现——倒排索引
CYK_byte的博客
09-23 932
第一次是根据用户输入的内容的词条，去找到对应的文档 id.第二次是拿着文档 id 来找文档.这样的查询效率，相比于正向索引中搜索 包含手机关键字的 数据，一行一行去查找就要快的多了.倒那么这里也能够看出，排索索引为什么是倒排了，因为正向索引中，得一行一行找，找到匹配的放到结果集中，而倒排索引就是反过来，基于词条创建索引，搜多的时候，就是根据词找到对应的文档（正向索引就是根据文档来找词）.
什么是正向索引、反向索引(倒排索引)？
生有涯，知无涯
01-18 1万+
1.正向索引 正向索引（正排索引）：正排表是以文档的ID为关键字，表中记录文档中每个字的位置信息，查找时扫描表中每个文档中字的信息直到找出所有包含查询关键字的文档。 “文档1”的ID > 单词1：出现次数，出现位置列表；单词2：出现次数，出现位置列表；…………。 “文档2”的ID > 此文档出现的关键词列表。 正排表结构如图1所示，这种组织方法在建立索引的时候结构比较简单，建立比较方...
信息检索——简单易懂的倒排索引（原理+例子）
热门推荐
土豆同学的博客
03-14 6万+
倒排索引 0 引言     今天介绍一下倒排索引，倒排索引又叫反向索引(inverted index)，既然有反向索引那就有正向索引(forward index)了。一些相关概念可以看前文信息检索(Information Retrieval)相关概念 1 正向索引和反向索引 先介绍一下正向索引: 当用户发起查询时（假设查询为一个关键词），搜索引擎会扫描索引库中的所有文档，找出所有包含关键词的文档，这样依次从文档中去查找是否含有关键词的方法叫做正向索引。互联网上存在的
【Elasticsearch入门到落地】2、正向索引和倒排索引
最新发布
程序猿之洞
11-24 1528
Elasticsearch的底层是由Lucene实现的，而Lucene中的核心技术就是“倒排索引”。“倒排索引”是与传统数据库的“正向索引”模式对比得出的一个名称。本篇将详细为大家介绍什么是“倒排索引”，以及“倒排索引”与“正向索引”有什么区别。
ElasticSearch——倒排索引和正向索引
万里顾一程的博客
11-04 4626
ElasticSearch——倒排索引和正向索引 1、正向索引 正向索引 (forward index) 以文档的ID为关键字，表中记录文档中每个字的位置信息，查找时扫描表中每个文档中字的信息直到找出所有包含查询关键字的文档 这种组织方法在建立索引的时候结构比较简单，建立比较方便且易于维护： 若是有新的文档加入，直接为该文档建立一个新的索引块，挂接在原来索引文件的后面。 若是有文档删除，则直接找到该文档号文档对应的索引信息，将其直接删除 缺点： 检索效率太低，只能在一起简单的场景下使用 假设有文档一
ES高频面试问题：一张图带你读懂 Elasticsearch 中“正排索引（正向索引）”和“倒排索引（反向索引）”区别
Elastic开源社区
05-10 4986
文章目录1、正排索引和倒排索引1.1 正排索引1.2 倒排&正排2、一张图看懂正排&倒排2.1 图解2.2 区别3、一个通俗易懂的比喻4、正排索引的数据结构4.1 doc values4.2 fielddata：5、总结 1、正排索引和倒排索引 1.1 正排索引 从广义来说，doc values 本质上是一个序列化的 列式存储 。列式存储 适用于聚合、排序、脚本等操作，所有的数字、地理坐标、日期、IP 和不分词（ not_analyzed ）字符类型都会默认开启，不支持text和annota
c++实现倒排索引算法
12-03
在C++中实现倒排索引算法可以帮助我们理解其原理并优化搜索性能。以下是对倒排索引算法及其C++实现的详细解释。 一、倒排索引的概念 倒排索引（Inverted Index）与传统的正向索引相反。在正向索引中，每个关键词...
文本全文搜索引擎 利用倒排索引实现
02-22
在这个主题中，我们将深入探讨倒排索引的概念、工作原理以及在Python中的实现。 **倒排索引概念** 倒排索引（Inverted Index）是一种用于快速查找文档中包含特定词汇的数据结构。与传统的正向索引（记录每个词出现...
python 实现倒排索引的方法
09-19
本文将详细介绍如何使用Python语言来实现倒排索引，并通过一个简单的例子来演示其工作原理。 #### 一、什么是倒排索引？ 倒排索引（Inverted Index），又称为反向索引或逆向索引，是一种用于快速查询文档集合中...
正排索引 vs 倒排索引 - 搜索引擎具体原理
Yawesh的博客
04-06 8264
本文全面解析了数据检索中的核心索引技术：正排索引和倒排索引，以及它们在搜索引擎中的应用。正排索引以文档的自然顺序组织数据，便于快速访问特定文档，而倒排索引则按关键词索引数据，优化了全文搜索的效率。文章通过实例阐释了两种索引的工作原理，比较了它们的优缺点，并讨论了各自的适用场景。此外，文章还深入探讨了搜索引擎的工作原理，从宏观的角度描述了搜索引擎的整体流程，以及从具体的角度分析了搜索引擎如何处理查询和呈现结果的详细步骤，展现了搜索引擎如何通过结合正排索引和倒排索引技术，为用户提供快速准确的搜索体验。
es_倒排索引详解
chuige2013的博客
03-07 2483
这也许是你全网你能找到的最详细的倒排索引的底层解读。博主把倒排索引的讲解划分为以下七个部分，理解难度递增，可根据自身需要选择依次阅读或者针对性阅读。通常来说，应付一般的面试，理解第一部分即可。如果需要面试搜索相关业务的岗位，需要深层次理解倒排索引，可根据自身情况选择阅读。
正向索引和倒排索引的区别
m0_63278070的博客
01-01 1388
1.正向索引可以给多个字段创建索引，根据索引搜索和排序的时候速度非常快，缺点是根据非索引字段，或者索引字段中的部分词条查找时，只能全表扫描，效率低。2.倒排索引在根据词条搜索，模糊搜索时，速度非常快，但是无法给词条创建索引，无法根据字段做排序。3.用户输入搜索条件时，会先对用户输入的内容进行分词，得到词条。2.创建表，表中每行的数据包括词条，文档的id，位置信息等等。1.如果是根据id查询，那么直接走索引，查询速度非常快。4.然后再用这个词条在倒排索引中查找，获取文档的id。
理解反向索引和正向索引
u012433915的专栏
06-28 1807
理解正向索引和反向索引
什么是正向索引？具体形式是什么样的？
GNET0328的博客
02-15 295
正向索引可以简称为索引。
正排索引和倒排索引
岁月静好
09-23 3万+
正排索引（正向索引） 正排表是以文档的ID为关键字，表中记录文档中每个字的位置信息，查找时扫描表中每个文档中字的信息直到找出所有包含查询关键字的文档。 正排表结构如图1所示，这种组织方法在建立索引的时候结构比较简单，建立比较方便且易于维护;因为索引是基于文档建立的，若是有新的文档加入，直接为该文档建立一个新的索引块，挂接在原来索引文件的后面。若是有文档删除，则直接找到该文档号文档对应的索引信息
搜索引擎系列1：什么是正向索引？什么是倒排索引？
一座青山的专栏
07-10 6877
什么是正向索引、什么是倒排索引？ 正向索引（forward index），反向索引（inverted index）更熟悉的名字是倒排索引。 在搜索引擎中每个文件都对应一个文件ID，文件内容被表示为一系列关键词的集合（实际上在搜索引擎索引库中，关键词也已经转换为关键词ID）。例如“文档1”经过分词，提取了20个关键词，每个关键词都会记录它在文档中的出现次数和出现位置，得到正向索引的结构如
python正向索引 反向索引_理解正向索引
weixin_39880615的博客
12-09 2319
倒排索引也叫做反向索引(inverted单词也有反转的意思，只不过大家喜欢翻译成倒排索引)。倒排索引在搜索引擎中经常用到，倒排索引也叫做反向索引。某天在想,为什么叫做倒排索引呢？倒过来的，反转过来的。那么，非倒排索引是什么样子的。解释一大堆。云里雾里。后来知道，反向索引是相对正向索引而言的，那什么是正向索引？我想，了解了正向索引，就能知道反向索引的产生背景了。下面是网上一些资料说法：每个文件都对应...
搜索引擎（正向索引，倒排索引）概念区别介绍
weixin_43231632的博客
05-06 1003
废话不多说，先上例子： 网页1中仅包含一句话：厦门SEO顾问潇湘驭文为您提供厦门SEO培训服务。 网页2中也仅包含一句话：SEO是一门艺术。 正向索引： 倒排索引： 正向索引：一般是通过key，去找value。例如：当用户在主页上搜索关键词“SEO”时，假设只存在正向索引（forward index），那么就需要扫描索引库中的所有文档，找出所有包含关键词“SEO”的文档。 倒排索引：从词的关键...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猩火燎猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值