Question

我有一个包含多个向量的向量。

示例：向量可能包含[1,2,3,4]和[5,6,7,8] 我如何找到这些向量的平均值？

它应该输出[3，4，5，6]。

这就是我尝试过的：

    double sum1 = 0;
    double sum2 = 0;
    double sum3 = 0;
    double sum4 = 0;

    for (int i = 0; i < VectorName.size(); i++)
    {
        sum1 = sum1 + VectorName[i][0];
        sum2 = sum2 + VectorName[i][1];
        sum3 = sum3 + VectorName[i][2];
        sum4 = sum4 + VectorName[i][3];
    }
    double avg1 = sum1/VectorName.size();
    double avg2 = sum2/VectorName.size();
    double avg3 = sum3/VectorName.size();
    double avg4 = sum4/VectorName.size();

所以，我的方法确实有效，但是，我想知道是否有更好的方法可以做到这一点……也许是某种预先构建的功能？

我是c ++的新手，请原谅我;）

Answer 1

考虑到您的问题，您似乎想遍历垂直形式的向量，而不是质量优先水平形式的向量：-

[1、2、3、4] + [5、6、7、8] = [6、8、10、12]

这也不是一种通用的方法，也不是一种简单的方法，但是无论如何，让我们乘车...

编辑：源已经过编辑，可以与模板兼容，因此您可以使用除int之外的任何其他内容（例如float，double等）

1）创建一个函数，该函数将遍历所有存储的向量（向量内），并确保它们的大小均相同（如果不相同，请在空白处添加零）：-

template<class TargetClass>
size_t EqualizeVectors(std::vector<std::vector<TargetClass>> &target, const bool equalize = true)
{
    if (target.empty())
        return 0;
    size_t greatest_size = 0;
    for (auto &elem : target)
        for (auto &elem2 : target)
            if (elem.size() > greatest_size)
                greatest_size = elem.size();
            else if (elem.size() > elem2.size())
                greatest_size = elem.size();
    if (equalize)
        for (auto &elem : target)
            for (auto i = 0; i < signed(greatest_size - elem.size()); i++)
                elem.emplace_back(0);
    return greatest_size;
}

现在我们有一个函数，可以将所有向量均等化到相同的大小，目标是您要在此过程中定位的向量，均衡只是要禁用在空格中添加零的过程（如果将Equalize更改为false，它将仅返回值，并且不执行其他任何操作）。

2）创建一个函数，该函数将汇总基本向量中存在的所有向量。（请注意，您尝试以垂直形式进行操作，因此会有所不同（例如 target[i][j] 成为 target[j][i]，等）：-

template<class TargetClass>
std::vector<TargetClass> GetVectorTotal(std::vector<std::vector<TargetClass>> target)
{
    const auto size = EqualizeVectors(target);
    std::vector<TargetClass> totals;
    for (auto i = 0; i < size; i++)
    {
        TargetClass sum = 0;
        for (auto j = 0; j < signed(target.size()); j++)
            sum += target[j][i];
        totals.emplace_back(sum);
        sum = 0;
    }
    return totals;
}

此函数的作用就是您所看到的，将基本向量中每个向量的 i 位置上出现的所有元素加起来，并返回包含所有和的结果向量。

3）创建一个将从结果总数中减去平均值的函数（现在这是一个简单的函数，也是可选的，您可以直接将其放在主函数中）：-

template<class TargetClass>
std::vector<TargetClass> GetVectorAverage(std::vector<std::vector<TargetClass>> &target, const bool omit_zero = true)
{
    std::vector<TargetClass> totals = GetVectorTotal(target);
    if (omit_zero)
        for (auto i = 0; i < signed(totals.size()); i++)
            if (totals[i] == 0)
                totals.erase(totals.begin() + i);
    std::vector<TargetClass> averages(totals.size());
    for (auto i = 0; i < signed(totals.size()); i++)
        averages[i] = totals[i] / target.size();
    return averages;
}

此功能首先从 total 参数中检查所有总计。 omit_zero 参数询问您是否要删除总数为零的数字。现在，您也提供了target.size()而不是total.size()中的averages[i] = totals[i] / target.size();，因为您更喜欢垂直方法。

现在，您都可以查找包含任意数量的任何向量的平均值。

示例：-

int main()
{
    std::vector<std::vector<int>> numbers
    {
        { 1, 2, 3, 4 },
        { 5, 6, 7, 8 }
    };
    auto averages = GetVectorAverage(numbers);
    std::cout << "[ ";
    for (auto &elem : averages)
        std::cout << elem << " ";
    std::cout << "]";
    return 0;
}

输出：

[3 4 5 6]

亲切的问候，

Ruks

从C ++中向量的向量中查找平均向量

1 个答案: