如何在 int 类型的 2D 向量中push_back数据

How can I push_back data in a 2d vector of type int

本文关键字：push back 数据 向量 2D int 类型      更新时间：2023-10-16

我有一个向量，想在运行时将 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);
}
}

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

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

您正在操作向量的向量。 因此，当声明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);
}

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

使用平面 2D 阵列

如果要存储 2D 数组，这不是最佳解决方案，因为：

  1. 数组数据分布在 N 个不同的动态分配缓冲区中(用于 N 行)
  2. 数组每行可以具有不同数量的列(因为没有任何内容强制执行该normal[i].size() == normal[j].size()

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

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;

创建一个临时向量将元素推送到这个临时向量中，然后将这个临时向量(在我的代码中为 v2)推送到一个 2d 向量(在我的代码中为 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";
}
}

如果不先分配外部和内部向量，就不能直接分配给[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);
}

你有一个向量向量。

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

这是另一种方法。

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

为每个索引分配 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;
}

我认为可以使用这样的指向子向量的指针。但是它仍然需要用一个空向量声明，然后我们才能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;
}

让我们用一个简单的贪婪问题来理解。 股票买卖：

一种方法是使用临时向量，即

vector<vector<int> > stockBuySell(vector<int> A, int n){
vector<vector<int>> v;
vector<int> temp;
for(int i=1;i<n;i++)
{
if(A[i]>A[i-1])
{
temp.push_back(i-1);
temp.push_back(i);
v.push_back(temp);
temp.clear();
}
}
return v;
}

另一种方法是：

vector<vector<int> > stockBuySell(vector<int> A, int n){
vector<vector<int>> v;
for(int i=1;i<n;i++)
{
if(A[i]>A[i-1])
v.push_back({i-1,i});
}
return v;
}

因此，如果我们必须在 2-d 向量中推送一些小尺寸的向量，例如 2 或 3，那么通过这种方式我们可以直接推送 2-d 向量，即 vector_name.push_back({1,2,3}); 同样使用 {} 括号。因此，我们不必使用任何额外的临时向量。

相关文章：