C++ std:：list<；标准：配对>；C++；STL？

std:：list

和

std:：map

之间有什么区别？列表是否也有

find

方法？

（澄清后编辑）

std:：map

针对快速搜索进行了优化。它有自己的

find

方法，使用其内部结构提供良好的性能。通常，它只检查

log（N）

键，其中N是地图中的项目数

---

std:：list

是一个简单的链表，因此只支持逐元素遍历。您可以使用单独的

std:：find

算法，或者

std:：find_if

与一个自定义谓词一起使用，该谓词只检查

第一个
成员，以便更好地匹配
std:：map:：find
的语义，但这将非常缓慢。事实上，对于任何失败的搜索，它必须查看列表中的每一对，对于任何成功的搜索，它将平均查看一半。
std:pair
正好包含两个对象<代码>标准：映射
保存成对对象的集合

您不能在对上使用find（），因为找不到任何内容。您想要的对象是
pair.First
或
pair.Second

更新：
假设您指的是
map
和
list
之间的区别：应该实现map以快速查找
键
成员<代码>列表

只有一个简单的线性列表。在列表中查找项目需要遍历整个列表。但是，std:：find（）可以同时处理这两个对象。

std:：pair仅用于将两个对象组合在一起（例如，“页面上的坐标”由X和Y压缩）

映射是从一组对象到另一组对象的映射

尝试对pair使用find方法是没有意义的，因为在一个包含两件事情的列表中查找某件事情是有意义的，您知道这两件事情的顺序，即使find方法存在于pair类中，但它不存在

但是，如果需要，可以使用std:：pair作为映射值。

std:：pair

std:：pair

是一种模板化元组结构，仅限于两项，称为第一项和第二项：

std::pair<int, std::string> myPair ;
myPair.first = 42 ;
myPair.second = "Hello World" ;

std:：pair

和

std:：map

注：这是对未经编辑的原始问题的回答

std:：map

函数需要同时将迭代器返回到键和值以保持效率。。。因此，显而易见的解决方案是将迭代器返回成对：

std::map<int, std::string> myMap ;
myMap[42] = "Fourty Two" ;
myMap[111] = "Hello World" ;

myMap.insert(std::make_pair(23, "Bye")) ;

std::map<int, std::string>::iterator it = myMap.find(42) ;
std::pair<int, std::string> keyvalue = *it ;    // We assume 42 does
                                                // exist in the map
int key = keyvalue.first ;
int value = keyvalue.second ;

std:：map myMap；
myMap[42]=“四十二”；
myMap[111]=“你好，世界”；
myMap.insert（std:：make_pair（23，“再见”）；
std:：map:：iterator it=myMap.find（42）；
std:：pair keyvalue=*it；//我们假设有42个
//存在于地图中
int key=keyvalue.first；
int value=keyvalue.second；

std:：list

和

std:：map

注：问题编辑后编辑

因此，乍一看，配对图和配对列表似乎是一样的。但事实并非如此：

映射本质上是由提供的函子排序的，而列表会将[A，B]对保留在您放置它们的位置。这使得映射的插入为O（logn），而列表中的原始插入是一个恒定的复杂性（搜索插入位置是另一个问题）

您可以使用成对列表来模拟映射的行为，但请注意，映射通常实现为项目树，而列表是链接的项目列表。因此，像二分法这样的算法在地图中的运行速度要比在列表中快得多

因此，在映射中查找项目是O（logn），而在无序列表中是O（n）。如果列表是有序的，并且您希望使用二分法，那么您将无法获得预期的性能提升，因为遍历项目列表是逐项完成的

---

（在我一年前参与的一个项目中，我们用一组相同的有序项替换了一个有序项列表，这提高了性能。该集合与映射具有相同的内部树结构，我想这里也会应用相同的增强）

STL映射是关联数组，通常在内部实现为哈希映射。如果您想在STL映射上进行迭代，它将返回一个STL对

#include <iostream>
#include <map>
#include <string>
using namespace std;
int main()
{
        map<string, int> myMap;
        myMap["myKey"] = 1337;

        map<string, int>::iterator myIterator = myMap.begin();

        pair<string, int> myPair = *myIterator;

        cout<<"the key \""<<myPair.first<<"\" maps to the value of "<<myPair.second<<endl;
        cout<<"the key \"myKey"\" maps to the value of "<<myMap["myKey"]<<endl;
        return 0;
}

#包括
#包括
#包括
使用名称空间std；
int main（）
{
地图我的地图；
myMap[“myKey”]=1337；
map:：iterator myIterator=myMap.begin（）；
pair myPair=*myIterator；
cout
std:：map
：


是一个关于键的有序结构（也就是说，当您对它进行迭代时，键将始终增加）
仅支持唯一键（
X
s）
提供快速
find（）
方法（
O（log n）
），该方法按键查找键值对
提供索引操作符
映射[key]
，速度也很快

std:：list
：


是成对的
X
s和
Y
s的简单序列。它们保持在您输入的顺序中
可以保存任意数量的副本
在
列表中查找特定键是
O（N）
（无特殊方法）

提供了
拼接
方法
Map在O（logn）范围内可以提供更好的搜索时间，
虽然列表有O（n）的搜索时间，但是， <代码> MAP>代码> s不是由哈希图实现的，而是红黑（或类似）树。有几个地方，STL文档不符合C++标准所设置的要求，因此读取STL API可以使您不实际使用它。（logn）查找，并且比不可变数据的映射更小（并且应该更快）。对于静态的、经常使用的查找非常有用。但是在显示优化将提供真正的好处之前，请使用映射。@chrispy:std:：vector仅在不可用时才提供O（logn）查找
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main()
{
        map<string, int> myMap;
        myMap["myKey"] = 1337;

        map<string, int>::iterator myIterator = myMap.begin();

        pair<string, int> myPair = *myIterator;

        cout<<"the key \""<<myPair.first<<"\" maps to the value of "<<myPair.second<<endl;
        cout<<"the key \"myKey"\" maps to the value of "<<myMap["myKey"]<<endl;
        return 0;
}