向量在C ++和push_back（）中的使用

Question

我是C ++的新手，可能在这里缺少一些非常基本的东西，但是我正在尝试创建向量的向量

#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(string s : strs)
        {
            string temp = s;
            sort(temp.begin(),temp.end());
            auto it = myMap.find(temp);
            if(it != myMap.end())
            {
                it->second.push_back(s);
            }
            else
            {
                vector<string> newVector;
                newVector.push_back(s);
                myMap.insert(pair<string,vector<string>>(temp,newVector));
                result.push_back(newVector);
            }
        }
        cout<< myMap["abt"].size() <<endl;
        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;
}

我期望输出看起来像这样

[
  ["ate", "eat","tea"],
  ["nat","tan"],
  ["bat"]
]

当我尝试在main（）中打印向量的向量时，向量的所有大小都为1。

好吧，当我在地图上打印矢量的尺寸时，这些尺寸在我看来就可以了。 我在这里想念什么？

更新-

使用以下更改修复了它

for(string s : strs)
{
    string temp = s;
    sort(temp.begin(),temp.end());
    auto it = myMap.find(temp);
    if(it != myMap.end())
    {
        it->second.push_back(s);
    }
    else
    {
        vector<string> newVector;
        newVector.push_back(s);
        myMap.insert(pair<string,vector<string>>(temp,newVector));
    }
}
for(auto it: myMap)
{
    result.push_back(it.second);
}

我仍然想知道是否有一种方法可以避免最终循环遍历地图并实现我最初打算要做的事情？

Answer 1

这是这部分：

{
    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，因为您永远不会返回地图本身。 此外，还有一种从一种容器类型转换为另一种容器类型的技术，例如， 此问题给出了有关所涉及内容的一些想法。

Answer 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));

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

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;
}       

Answer 3

我仍然想知道是否有一种方法可以避免最终循环遍历地图并实现我最初打算要做的事情？

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;

只需得出结果并映射类的成员即可。 请参阅将类型更改为vector的vector的指针。

        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

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