将向量拆分为新的较小的向量

Question

问题

我有向量V = {1,2,3,4,5,6,7,8,9,10,11}，假设我想从这个大向量创建N新向量。

示例：N = 3意味着它将按最大可用大小(即4-4-3 )将向量拆分。

v1 = {1,2,3,4}

v2 = {5,6,7,8}

v3 = {9,10,11}

代码

std::vector<int> v;
for (int i = 1; i < 12; i++) v.push_back(i);   

// Function here to set boundaries ???
N = 3;
v.size()/N % N
//
std::vector<int> v1(v.begin(), v.begin()+3);
std::vector<int> v2(v.begin()+4, v.begin()+7);
std::vector<int> v3(v.begin()+8, v.begin()+11);

想要实现

自动生成向量的possible.

• And

• 函数，因此我不想手动创建v1,v2,v3，如果是v1,v2,v3，如何编写边界检查算法?

Answer 1

一个简单的方法是构建一个vector of vector来收集不同的数组。

要控制边界，一种可能的方法是先计算这些数组的最大大小，然后管理两个索引，一个对应于子数组开头的ibegin，另一个对应于同一子数组结尾的iend。

输出：

1 2 3 4
5 6 7 8
9 10 11

代码：

#include <iostream>
#include <vector>

std::vector<std::vector<int>> split (const std::vector<int>& v, int Nsplit) {
    int n = v.size();
    int size_max = n / Nsplit + (n % Nsplit != 0);
    std::vector<std::vector<int>> split;
    for (int ibegin = 0; ibegin < n; ibegin += size_max) {
        int iend = ibegin + size_max;
        if (iend > n) iend = n;
        split.emplace_back (std::vector<int>(v.begin() + ibegin, v.begin() + iend));
    }
    return split;
}

int main() {
     std::vector<int>Arr = {1,2,3,4,5,6,7,8,9,10,11};
     int Nsplit = 3;
     auto ans = split (Arr, Nsplit);
     
    for (auto &v: ans) {
        for (auto& i: v) {
            std::cout << i << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

Answer 2

如果将vec块分成如下所示的n块，就会得到第一个块：

template <typename T>
std::span<T> get_chunk(std::vector<T> const & vec, std::size_t n, std::size_t i)
{
  assert(i < n);
  std::size_t const q = vec.size() / n;
  std::size_t const r = vec.size() % n;
  
  auto begin = vec.begin() + i * q + std::min(i, r);
  auto end = vec.begin() + (i + 1) * q + std::min(i + 1, r);
  
  return std::span<T>(begin, end);
}

如果您不能/不能使用std::span，只需将其替换为std::vector或直接使用begin和end-iterators即可。

Answer 3

函数，它自己自动创建向量，所以如果可能的话，我不想手动创建v1、v2、v3。

什么数据结构可以容纳N个对象？列阵怎么样？但您可能希望在运行时确定大小。如何创建一个具有运行时大小的数组？用矢量！总之，编写一个创建向量向量的函数。

请注意，与其使用单独的向量，不如保持原始向量不变，并使用指向子范围的std::span向量(在C++20之前，您可以使用相同概念的非标准实现)。