如何在 int 类型的二维向量中 push_back 数据答案

【问题标题】：How can I push_back data in a 2d vector of type int如何在 int 类型的二维向量中 push_back 数据
【发布时间】：2017-07-04 02:37:33
【问题描述】：

我有一个向量，想在运行时将 int 数据存储到其中，我可以以这种方式将数据存储在 2D 向量中吗？

std::vector<std::vector <int>> normal:
    for(i=0;i<10;i++){
        for(j=0;j<20;j++){
            normal[i].push_back(j);
    }
}

【问题讨论】：

你没有一个“二维向量”，你有一个向量 of 个向量 int。如果你记得很容易看出你需要做什么：为外循环的每次迭代推回一个向量。
或者如果在声明时知道大小，您可以将其传递给构造函数或调用 resize
感谢您的解释，我对此有点困惑

标签： c++ multidimensional-array vector

【解决方案1】：

是的，但您还需要推送每个子向量：

std::vector<std::vector<int>> normal;
for(int i=0; i<10; i++)
{
    normal.push_back(std::vector<int>());
    for(int j=0; j<20; j++)
    {    
        normal[i].push_back(j);    
    }
}

【讨论】：

【解决方案2】：

如果不先分配外部向量和内部向量，则不能直接分配给[i]。一种解决方案是在 for 循环中创建内部向量，然后在填充这些向量后，将它们 push_back 到外部向量。

std::vector<std::vector<int>> normal;
for(i=0;i<10;i++)
{
    std::vector<int> temp;
    for(j=0;j<20;j++)
    {
        temp.push_back(j);
    }
    normal.push_back(temp);
}

【讨论】：

【解决方案3】：

你有一个向量的向量。

normal[i] 不存在，因为你没有创建它。

std::vector<std::vector <int> > normal:
for(i=0;i<10;i++){
    normal.emplace_back();
    for(j=0;j<20;j++){
        normal.back().push_back(j);
    }
}

for(i=0;i<10;i++){
    for(j=0;j<20;j++){
        std::cout << normal[i][j] << " ";
    }
    std::cout << std::endl;
}

【讨论】：

【解决方案4】：

您正在处理向量的向量。因此，当声明normal 时，它是空的并且不包含任何元素。

你可以：

在插入元素之前调整向量的大小

std::vector<std::vector<int> > normal;
normal.resize(20);

for (size_t i = 0; i < normal.size(); ++i)
{
    for (size_t j = 0; j < 20; ++j)
        normal[i].push_back(j);
}

这可能比在其他答案中提出的在每个步骤中推送一个空向量更有效。

使用平面二维数组

如果你想存储一个二维数组，这不是最优方案，因为：

您的数组数据分布在 N 个不同的动态分配缓冲区（用于 N 行）
你的数组每行可以有不同数量的列（因为没有任何东西强制normal[i].size() == normal[j].size()

相反，您可以使用大小为N * M 的向量（其中N 是行数，M 是列数），并使用i 和列j 访问元素索引i + j * N：

size_t N = 20;
size_t M = 20;
std::vector<int> normal;
normal.resize(N * M);

for (size_t i = 0; i < N; ++i)
    for (size_t j = 0; j < M; ++j)
        normal[i + j * N] = j;

【讨论】：

我想你的意思是说normal.resize(10)代表列的长度

【解决方案5】：

这是另一种方法。

#include <iostream>
#include <iomanip>
#include <vector>
#include <numeric>

int main() 
{
    std::vector<std::vector <int> > normal;
    normal.resize( 10, std::vector<int>( 20 ) );

    for ( auto &v : normal ) std::iota( v.begin(), v.end(), 0 );

    for ( const auto &v : normal )
    {
        for ( int x : v ) std::cout << std::setw( 2 ) << x << ' ';
        std::cout << std::endl;
    }
}

程序输出是

 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19

可以写一个对应的函数

#include <iostream>
#include <iomanip>
#include <vector>
#include <numeric>

template <typename T>
T & init_2d( T &container, size_t m, size_t n )
{
    container.resize( m, typename T::value_type( n ) );

    for ( auto &item : container ) std::iota( item.begin(), item.end(), 0 );

    return container;
}

int main() 
{
    std::vector<std::vector<int>> v;

    for ( const auto &v : init_2d( v, 10, 20 ) )
    {
        for ( int x : v ) std::cout << std::setw( 2 ) << x << ' ';
        std::cout << std::endl;
    }

}

【讨论】：

【解决方案6】：

分配n个空向量，即为每个索引分配一个空向量。然后 push_back() 就可以应用了。

int main()
{
    int n = 10;
    std::vector<std::vector<int>> normal;
    normal.resize(n);   //Allocating 'n' empty vectors
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < 20; j++)
        {
             normal[i].push_back(j);
        }
    }
    return 0;
}

【讨论】：

您能否在答案中说明您的答案与其他人的主要区别是什么？

【解决方案7】：

我认为可以使用这种指向子向量的指针。但是在我们可以 push_back() 子向量之前，它仍然需要声明一个空向量。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

int main () {
    vector<vector<ll>> normal;
    for (ll i=0; i<10; i++) {
        normal.push_back({}); //init empty sub vector
        for (ll j=0; j<20; j++) {
            vector<ll>& temp = normal[i]; //point the sub vector
            temp.push_back(j);            //pus_back the sub vector
        }
    }
    for (ll i=0; i<10; i++) {
        for (ll j=0; j<20; j++) {
            printf("%lld ", normal[i][j]);
        }printf("\n");
    }
    return 0;
}

【讨论】：

【解决方案8】：

创建一个临时向量，将元素推送到这个临时向量中，然后将这个临时向量（我的代码中的 v2）推送到二维向量（我的代码中的 v1）。

#include <iostream>
#include <bits/stdc++.h>
#include<algorithm>
 using namespace std;

 int main()
 {

    vector<vector<int>> v1;
    vector<int> v2;
    v2.push_back(1);
    v2.push_back(2);
    v2.push_back(13);
    v2.push_back(14);
    v2.push_back(15);

    v1.push_back(v2);
    //i pushed v2 into v1

    int j=0;
    for(int i=0 ; i<5 ;i++)
    {
        cout<<v1[0][i]<<"\t";
    }
  }

【讨论】：