C++ 如何迭代STL映射（找到所有可能的对）

如何迭代STL映射以对抗所有元素。换句话说，我想找到所有可能的配对。我想要一个高效的算法（复杂度）

如果有STL向量，算法简单

vector<int> vInt;
vector<pair<int, int> > vPair;
for(int i = 0; i < vInt.size(); i++) {
    for(int j = i + 1; j < vInt.size(); j++) {
        vPair.push_back(make_pair(vInt[i], vInt[j]));
    }
}

vectorvint；
矢量vPair；
对于（int i=0；i

但是，如果您有一个STL映射原样算法

Obs：我想要地图的所有可能的组合（不是键）

map；
矢量vPair；
???

---

我曾想过在STL向量中转换为STL映射，但是我会使用一种只使用STL映射的方法，非常简单，映射有开始和结束迭代器，就像向量一样，所以您可以这样做

#include <map>                                                                     
int main()                                                                         
{                                                                                  
    std::map<int,int> map;                                                         
    for (auto p : map) {                                                           
        auto f = p.first;                                                          
        auto s = p.second;                                                         
    }                                                                              
    return 0;                                                                      
}     

#包括
int main（）
{                                                                                  
地图；
对于（自动p:map）{
自动f=p.优先；
自动s=每秒；
}                                                                              
返回0；
}     

即使是

std:：unordered_映射

也有开始和结束迭代器，但它不像映射那样保持顺序

---

你的问题不清楚你是否想要向量中数字的笛卡尔积，我能说的是，如果你想要的是笛卡尔积，你最初的方法比使用映射更好。

非常简单，映射有开始和结束迭代器，就像向量一样，所以你可以这样做

#include <map>                                                                     
int main()                                                                         
{                                                                                  
    std::map<int,int> map;                                                         
    for (auto p : map) {                                                           
        auto f = p.first;                                                          
        auto s = p.second;                                                         
    }                                                                              
    return 0;                                                                      
}     

#包括
int main（）
{                                                                                  
地图；
对于（自动p:map）{
自动f=p.优先；
自动s=每秒；
}                                                                              
返回0；
}     

即使是

std:：unordered_映射

也有开始和结束迭代器，但它不像映射那样保持顺序

从你的问题中不清楚你是否想要向量中数字的笛卡尔积，我能说的是，如果你想要的是笛卡尔积，那么你最初的方法比使用映射更好。

使用

begin（）

和

end（）

，这两种方法都可以迭代

向量和
映射的所有元素

for (std::map<int, int>::iterator it = mymap.begin(); it != mymap.end(); ++it)
{
    std::cout << it->first << "  => " << it->second << '\n';
}

for（std:：map:：iterator it=mymap.begin（）；it！=mymap.end（）；+it）
{
std:：cout first使用
begin（）
和
end（）
，这两种方法都可以迭代
向量和
映射的所有元素

for (std::map<int, int>::iterator it = mymap.begin(); it != mymap.end(); ++it)
{
    std::cout << it->first << "  => " << it->second << '\n';
}

for（std:：map:：iterator it=mymap.begin（）；it！=mymap.end（）；+it）
{
std：：cout first我喜欢这种方法

map<int, int> m;
m[1] = 1;
m[2] = 2;
m[3] = 3;
m[4] = 4;
map<int, int>::iterator itr1;
for(itr1 = m.begin(); itr1 != m.end(); ++itr1) {
    map<int, int>::iterator itr2 = itr1;
    for(++itr2; itr2 != m.end(); ++itr2) {
        cout << m[itr1->second] << " : " << m[itr2->second] << endl;
    }
}

map-m；
m[1]=1；
m[2]=2；
m[3]=3；
m[4]=4；
迭代器itr1；
对于（itr1=m.begin（）；itr1！=m.end（）；+itr1）{
迭代器itr2=itr1；
对于（++itr2；itr2！=m.end（）；++itr2）{
我喜欢这种方法

map<int, int> m;
m[1] = 1;
m[2] = 2;
m[3] = 3;
m[4] = 4;
map<int, int>::iterator itr1;
for(itr1 = m.begin(); itr1 != m.end(); ++itr1) {
    map<int, int>::iterator itr2 = itr1;
    for(++itr2; itr2 != m.end(); ++itr2) {
        cout << m[itr1->second] << " : " << m[itr2->second] << endl;
    }
}

map-m；
m[1]=1；
m[2]=2；
m[3]=3；
m[4]=4；
迭代器itr1；
对于（itr1=m.begin（）；itr1！=m.end（）；+itr1）{
迭代器itr2=itr1；
对于（++itr2；itr2！=m.end（）；++itr2）{
cout second]“我希望所有可能的组合都是map的值（而不是键）”

我不确定你想要什么，但如果你想完全像你在例子中对向量所做的那样，在地图的“值”上

您可以按如下方式进行操作：

std::map<int, int> map;
std::map<int,int>::iterator i,j,end=m.end();  
std::vector<std::pair<int,int> > vpair;
end--;
for(i=m.begin();i!=end;++i)
{
    j=i;
    j++;
    for(;j!=m.end();++j)
        vpair.push_back(std::make_pair(i->second,j->second));
 }

std:：map；
std:：map:：迭代器i，j，end=m.end（）；
std：：矢量vpair；
结束--；
for（i=m.begin（）；i！=end；++i）
{
j=i；
j++；
对于（；j！=m.end（）；++j）
vpair.push_back（std:：make_pair（i->second，j->second））；
}
“我希望所有可能的组合都是map的值（而不是键）”

我不确定你想要什么，但如果你想完全像你在例子中对向量所做的那样，在地图的“值”上

您可以按如下方式进行操作：

std::map<int, int> map;
std::map<int,int>::iterator i,j,end=m.end();  
std::vector<std::pair<int,int> > vpair;
end--;
for(i=m.begin();i!=end;++i)
{
    j=i;
    j++;
    for(;j!=m.end();++j)
        vpair.push_back(std::make_pair(i->second,j->second));
 }

std:：map；
std:：map:：迭代器i，j，end=m.end（）；
std：：矢量vpair；
结束--；
for（i=m.begin（）；i！=end；++i）
{
j=i；
j++；
对于（；j！=m.end（）；++j）
vpair.push_back（std:：make_pair（i->second，j->second））；
}
您可以使用
j=std:：next（i）
来实现
j=i+1
，那么代码几乎与向量情况相同：

std::map<int, int> map;
vector<pair<int, int>> vPair;
for (auto i = map.begin(); i != map.end(); i++) {
  for (auto j = std::next(i); j != map.end(); j++) {
    vPair.push_back(std::make_pair(i->second, j->second));
  }
}

std:：map；
矢量vPair；
for（自动i=map.begin（）；i！=map.end（）；i++）{
for（auto j=std:：next（i）；j！=map.end（）；j++）{
vPair.push_back（std:：make_pair（i->second，j->second））；
}
}
您可以使用
j=std:：next（i）
来实现
j=i+1
，那么代码几乎与向量情况相同：

std::map<int, int> map;
vector<pair<int, int>> vPair;
for (auto i = map.begin(); i != map.end(); i++) {
  for (auto j = std::next(i); j != map.end(); j++) {
    vPair.push_back(std::make_pair(i->second, j->second));
  }
}

std:：map；
矢量vPair；
for（自动i=map.begin（）；i！=map.end（）；i++）{
for（auto j=std:：next（i）；j！=map.end（）；j++）{
vPair.push_back（std:：make_pair（i->second，j->second））；
}
}
根据定义，对于大小为n的映射，映射中的对数为n*（n-1）/2。因此，没有比向量算法更有效的算法了。所有可能的对、键或映射值组合？我曾想过在STL向量中转换为STL映射，但我