在 C++ 和 push_back( ) 中使用向量的向量

是这部分：

{
    vector<string> newVector;
    newVector.push_back(s);
    myMap.insert(pair<string,vector<string>>(temp,newVector));
    result.push_back(newVector);
}

每次result都会被赋予一个具有一个元素的新向量。对地图矢量的更改起作用而不是矢量矢量的原因是vector::push_back每次都会创建一个副本。

要解决这个问题，有两种方法。

您可以尝试在更新地图
1. 的同时更新结果，并让向量存储对地图副本的一些引用。
2. 由于您不将result用于处理步骤，仅用于结果，因此您可以在完成地图后编译矢量。

我更喜欢方法 #2，因为您永远不会返回地图本身。此外，从一种容器类型转换到另一种容器类型还有一门艺术，例如，这个问题给出了一些关于所涉及的内容的想法。

问题出在代码的这一部分：

vector<string> newVector;
newVector.push_back(s);
myMap.insert(pair<string,vector<string>>(temp,newVector));
result.push_back(newVector);

细分：

vector<string> newVector;

创建新的局部临时向量。

newVector.push_back(s);

为newVector后面的string分配空间，并将s复制到其中。

myMap.insert(pair<string,vector<string>>(temp,newVector));

创建一个 std：:p air 包含一个 temp 副本和一个 newVector 副本 - 按原样，然后为映射中的匹配对分配空间，并将临时对（即再次复制字符串和向量）复制到其中。

result.push_back(newVector);

这会在结果的后面为新向量分配空间，并将newVector复制到其中。

此时，result和myMap包含newVector的独立快照。代码的其余部分更新了myMap的向量，但结果保持不变。

您可以通过不即时构建result来解决此问题，而仅在完成所有工作后构建它：

    // take a reference to each string in the vector,
    // const indicates it will be immutable
    for(const string& s : strs)
    {
        string temp = s;
        sort(temp.begin(),temp.end());
        std::vector<string>& dest = myMap[temp];
        dest.emplace_back(s);
    }
    cout<< myMap["abt"].size() <<endl;
    for (auto& kv : myMap)  // kv: key value
    {
        // std::move tells 'emplace_back' it can steal the
        // vector's data right out of kv.second.
        result.emplace_back(std::move(kv.second));
    }

生成的代码如下所示：http://ideone.com/eofloM

#include <iostream>
#include <stack>
#include <string>
#include <map>
#include <vector>
#include <algorithm>

using namespace std;
class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs)
    {
        vector<vector<string>> result;
        map<string,vector<string>> myMap;
        if(strs.size() == 0)
        {
            return result;
        }
        for(const string& s : strs)
        {
            string temp = s;
            sort(temp.begin(),temp.end());
            std::vector<string>& dest = myMap[temp];
            dest.emplace_back(s);
        }
        cout<< myMap["abt"].size() <<endl;
        for (auto& kv : myMap)  // kv: key value
        {
            result.emplace_back(std::move(kv.second));
        }
        return result;
    }
};

int main(int argc, const char * argv[])
{
    Solution mySolution;
    vector<string> myStrings {"eat", "tea", "tan", "ate", "nat", "bat"};
    auto result = mySolution.groupAnagrams(myStrings);
    for(vector<string> v: result)
    {
        //cout << v.size() << endl;
        for(string s: v)
        {
            cout << s << " ";
        }
        cout << endl;
    }
    return 0;
}       

我

仍然有兴趣知道是否有办法避免最终循环浏览地图并实现我最初打算做的事情？

class Solution {
private:
        vector<vector<string>*> result;
        map<string,vector<string>> myMap;
public:
    vector<vector<string>*> groupAnagrams(vector<string>& strs)
    {
//        vector<vector<string>*> result;
//        map<string,vector<string>> myMap;

只需制作结果并映射类的成员即可。看到类型更改为矢量指针的矢量。

        else
        {
            vector<string> newVector;
            newVector.push_back(s);
            auto p = myMap.insert(pair<string,vector<string>>(temp,newVector));
            //p is pair<iterator, bool>
            //where iterator is pointing to the inserted element
            //so p.first->second is the new vector
            result.push_back(&(p.first->second));
        }

请注意，这里我们将向量的地址放在地图中。

for(vector<string>* v: result)
{
    for(string s: *v)
    {
        cout << s << " ";
    }
    cout << endl;
}

迭代向量并考虑指针类型，结果如下：

eat tea ate 
tan nat 
bat

这占用了第二个循环并使用更少的空间，但使代码有点复杂。