C++ C++；：具有两个相关键的快速结构

我有一个容器需要保存一个ID（ID是唯一的）和一个数据值。我还需要把这些ID整理好。这些变量的元组将由ID查找，但随后将按顺序处理到找到的元素，即我并不总是希望处理整个容器。对于这个，我有一个简单的解决方案

// ordinal, { ID, data }
std::map<int64, pair<int64, data_t> >

//序号，{ID，data}
标准：：地图

---

我将首先通过迭代并将搜索值与对的第一个字段进行比较来搜索ID，给我一个迭代器，然后我将处理所有元素，直到这个位置。有没有更好的方法来实现这一点（据我统计，这是O（2n））？

如果您想对值和键进行索引，可以使用Boost.Bimap。这样，您可以根据其值在地图中查找一对。如果没有此项或类似项，则必须使用蛮力（=>手动迭代地图）

---

否则，您可以使用来帮助您找到具有正在查找的ID的配对，但速度与在地图上迭代的速度相同。

如果您希望对值和键进行索引，则可以使用Boost.Bimap。这样，您可以根据其值在地图中查找一对。如果没有此项或类似项，则必须使用蛮力（=>手动迭代地图）

---

否则，您可以使用来帮助您找到具有您正在查找的ID的配对，但其速度将与在地图上迭代的速度相同。

您可以交换

序号

和

ID

，并将其存储在地图中：

//                 ID              ordinal data
std::unordered_map<int64, std::map<int64, data_t>> container;

然后，您可以将找到的对象的

序号

与给定的阈值进行比较

---

UP:当然，如果您的

ID

s是唯一的，那么嵌套的

map

中就不需要了：您只需使用

std:：unordered_map

就可以交换

ordinal

和

ID

并将它们存储在地图中：

//                 ID              ordinal data
std::unordered_map<int64, std::map<int64, data_t>> container;

然后，您可以将找到的对象的

序号

与给定的阈值进行比较

---

UP:当然，如果您的

ID

s是唯一的，那么嵌套的

map

中就不需要了：您可以只使用

std:：unordered_map

如果序号严格用于维护顺序，并且不会有任何间隙，我会做一些简单的事情，比如：

    int64_t givenID = whereToQuit;

    std::vector< int64_t >                ordinal_to_ID; 
    std::unordered_map< int64_t, data_t > data_map;

    using datapair_t = std::pair< int64_t, data_t >;
    void do_whatever( datapair_t );

    bool done = false;
    do 
    {
        int64_t ID = ordinal_to_ID[ i ];
        do_whatever( datapair_t( ID, data_map[ ID ]) ); 
        done = ID == givenID;
    }
    while ( !done );

int64\t givenID=whereToQuit；
std：：vector序数到ID；
std：：无序地图data地图；
使用datapair_t=std:：pair；
无效做任何事情（数据对）；
bool done=false；
做
{
int64_t ID=顺序到_ID[i]；
做任何事（数据对（ID，数据映射[ID]）；
done=ID==givenID；
}
而（！完成）；

如果序号严格用于维护顺序，并且不会有任何间隙，我会做一些简单的事情，比如：

    int64_t givenID = whereToQuit;

    std::vector< int64_t >                ordinal_to_ID; 
    std::unordered_map< int64_t, data_t > data_map;

    using datapair_t = std::pair< int64_t, data_t >;
    void do_whatever( datapair_t );

    bool done = false;
    do 
    {
        int64_t ID = ordinal_to_ID[ i ];
        do_whatever( datapair_t( ID, data_map[ ID ]) ); 
        done = ID == givenID;
    }
    while ( !done );

int64\t givenID=whereToQuit；
std：：vector序数到ID；
std：：无序地图data地图；
使用datapair_t=std:：pair；
无效做任何事情（数据对）；
bool done=false；
做
{
int64_t ID=顺序到_ID[i]；
做任何事（数据对（ID，数据映射[ID]）；
done=ID==givenID；
}
而（！完成）；

您可以使用std:：map而不是std:：pair，这样可以加快搜索速度，但会浪费内存。您是否在此处显示了ID？

map

中的查找是O（logn），而不是O（n）。第一个是序数，第二个（成对中）是ID。在该方案下，我不进行查找，只是迭代两次。正在向我传递ID，从中我需要找到处理元素的顺序，以达到并包括此顺序在搜索时不处理

映射

元素的原因是什么？为什么用

map

而不是

vector

，你会乱序插入序数？你可以用std:：map而不是std:：pair，这样搜索速度会更快，但会浪费你的内存。你在这里显示的

int64

都是ID吗？

map

中的查找是O（logn），而不是O（n）。第一个是序数，第二个（成对中）是ID。在该方案下，我不进行查找，只是迭代两次。正在向我传递ID，从中我需要找到处理元素的顺序，以达到并包括此顺序在搜索时不处理

映射

元素的原因是什么？为什么用

映射

而不是

向量

，你会按顺序插入序数？