地图何时变得比两个向量更好？

Question

地图对其所有元素进行二元搜索，这些元素具有对数复杂度 - 这意味着对于足够小的对象集合，地图将比具有线性搜索的两个向量执行得更差。

对象（关键字）池应该有多大才能使地图开始比两个向量表现更好？

编辑：问题的更通用版本：对象池应该有多大，以便二进制搜索比线性搜索更好？

我使用字符串作为键，值是指针，但我的特定用例可能无关紧要。 我更好奇地了解如何正确使用这两个工具。

Answer 1

如果你原谅我这么说的话，大多数答案听起来像我说的各种方式：“我不知道”，没有实际承认他们不知道。 虽然我普遍同意他们给出的建议，但似乎没有人试图直接解决你提出的问题：什么是收支平衡点。

公平地说，当我读到这个问题时，我也不知道。 这是我们所知道的基本知识之一：对于足够小的集合，线性搜索可能会更快，而对于足够大的集合，二进制搜索无疑会更快。 然而，我从来没有太多理由去调查关于盈亏平衡点的真实情况。 然而，你的问题让我很好奇，所以我决定编写一些代码来至少得到一些想法。

这段代码肯定是一个非常快速的黑客攻击（很多重复，目前只支持一种类型的密钥等），但至少它可能会让人知道会发生什么：

#include <set>
#include <vector>
#include <string>
#include <time.h>
#include <iostream>
#include <algorithm>

int main() {   

    static const int reps = 100000;

    std::vector<int> data_vector;
    std::set<int> data_set;
    std::vector<int> search_keys;

    for (int size=10; size<100; size += 10) {
        data_vector.clear();
        data_set.clear();
        search_keys.clear();

        int num_keys = size / 10;   
        for (int i=0; i<size; i++) {
            int key = rand();

            if (i % num_keys == 0)
                search_keys.push_back(key);

            data_set.insert(key);
            data_vector.push_back(key);
        }

        // Search for a few keys that probably aren't present.
        for (int i=0; i<10; i++)
            search_keys.push_back(rand());

        long total_linear =0, total_binary = 0;

        clock_t start_linear = clock();
        for (int k=0; k<reps; k++) {
            for (int j=0; j<search_keys.size(); j++) {
                std::vector<int>::iterator pos = std::find(data_vector.begin(), data_vector.end(), search_keys[j]);
                if (pos != data_vector.end())
                    total_linear += *pos;
            }
        }
        clock_t stop_linear = clock();                      

        clock_t start_binary = clock();
        for (int k=0; k<reps; k++) {
            for (int j=0; j<search_keys.size(); j++) {
                std::set<int>::iterator pos = data_set.find(search_keys[j]);
                if (pos != data_set.end())
                    total_binary += *pos;
            }
        }
        clock_t stop_binary = clock();

        std::cout << "\nignore: " << total_linear << " ignore also: " << total_binary << "\n";

        std::cout << "For size = " << size << "\n";
        std::cout << "\tLinear search time = " << stop_linear - start_linear << "\n";
        std::cout << "\tBinary search time = " << stop_binary - start_binary << "\n";
    }
    return 0;
}

以下是我在我的机器上运行的结果：

ignore: 669830816 ignore also: 669830816
For size = 10
        Linear search time = 37
        Binary search time = 45

ignore: 966398112 ignore also: 966398112
For size = 20
        Linear search time = 60
        Binary search time = 47

ignore: 389263520 ignore also: 389263520
For size = 30
        Linear search time = 83
        Binary search time = 63

ignore: -1561901888 ignore also: -1561901888
For size = 40
        Linear search time = 106
        Binary search time = 65

ignore: -1741869184 ignore also: -1741869184
For size = 50
        Linear search time = 127
        Binary search time = 69

ignore: 1130798112 ignore also: 1130798112
For size = 60
        Linear search time = 155
        Binary search time = 75

ignore: -1949669184 ignore also: -1949669184
For size = 70
        Linear search time = 173
        Binary search time = 83

ignore: -1991069184 ignore also: -1991069184
For size = 80
        Linear search time = 195
        Binary search time = 90

ignore: 1750998112 ignore also: 1750998112
For size = 90
        Linear search time = 217
        Binary search time = 79

显然，这不是唯一可能的测试（甚至接近最好的测试），但在我看来，即使是一点点硬数据也比没有更好。

编辑：我会注意到记录，我认为没有理由使用两个向量（或对向量）的代码不能像使用集合或映射的代码一样干净。 显然，你会想要把它的代码到一个小它自己的阶级，但我看不出有任何理由可言，它可能不存在完全相同的界面向外界表明map一样。 事实上，我可能只是称它为“tiny_map”（或该命令中的某些东西）。

面向对象编程的基本要点之一（在通用编程中仍然如此，至少在某种程度上）是将接口与实现分开。 在这种情况下，您所说的纯粹是一个不需要影响接口的实现细节。 事实上，如果我正在编写一个标准库，我很想把它作为一个“小地图优化”，类似于常见的小字符串优化。 基本上，只需在map对象本身中直接分配一个包含value_type的10个（或左右）对象的数组，并在/如果地图很小时使用它们，然后将数据移动到树中，如果它变大到足以证明它的合理性。 唯一真正的问题是人们是否经常使用微小的地图来证明这项工作的合理性。

Answer 2

map的代码比两个vector的代码要清晰得多; 那应该是你最关心的问题。 只有当您确定map的性能在您自己的应用程序中存在问题时，您才会担心差异，此时您应该自己对其进行基准测试。

Answer 3

地图永远不会等于有序矢量搜索速度，因为矢量内存更好地打包，内存访问更直接。

然而，这只是故事的一半。 一旦开始修改容器，节点基容器（不需要在其元素周围移动以容纳中间的插入），就可以获得理论上的优势。 与搜索一样，更好的缓存局部性仍然为少量元素提供了矢量边缘。

精确的测量很难提供，并且取决于具体的优化，上下文使用和机器，因此我建议简单地按功能进行。 地图有一个按键搜索的自然界面，所以使用它会让你的生活更轻松。

如果你真的发现自己正在测量并且需要真正地从性能中挤出性能，那么你可能需要更专业的数据结构。 查找B树。