Question

我正在寻找一个运行时效率小工具，它可以添加（成对）存储在两个整数向量（vector<int> a和vector<int> b）中的整数值，这也是内存效率高的。假设矢量大小不同或相等。

我得到的是：

    vector<int> c;
    if( a.size() > b.size() )
    {
       for( size_t i = 0 ; i < b.size() ; ++i )
       {
          c.push_back(a[i]+b[i]);
       }
    else if ( a.size() < b.size() )
    {
       for( size_t i = 0 ; i < a.size() ; ++i )
       {
          c.push_back(a[i]+b[i]);
       }
    }
    else
    {
       for( size_t i = 0 ; i < a.size() ; ++i )
       {
          c.push_back(a[i]+b[i]);
       }
    }

示例：

vector<int> a - ＆gt; （0）（12）（0）（0）（123）（12）

vector<int> b - ＆gt; （305）（10）（3）（4）（8201）（230）（0）（0）（0）

vector<int> c - ＆gt; （305）（22）（3）（4）（8324）（242）（0）（0）（0）

Answer 1

您可以使用std::transform：

#include <algorithm>  // for transform and min
#include <functional> // for std::plus
#include <iterator>   // for std::begin, but it's
                      // implicitly included by <vector>
std::vector<int> a;
std::vector<int> b;
auto size = std::min(a.size(), b.size()); 
std::vector<int> c(size); // creates the third vector big enough for results

std::transform(
    begin(a), begin(a)+size, begin(b),
    begin(c), std::plus<int>()
);

在std::transform下面只是一个循环，它从每个范围中取一个元素（由前三个参数定义），对它们应用二进制函数（最后一个参数std::plus<int>）并将结果存储在第三个范围（第四个参数）。

没有任何好转w.r.t. “运行时效率”比迭代所有元素。您的解决方案接近最佳。但是标准算法具有明确意图的额外好处，并且编译器可能知道如何有效地优化它们。

Answer 2

std::vector<int> c;
const size_t minSize = std::min(a.size(), b.size());
c.reserve(minSize); // avoids useless reallocation
for (size_t i = 0; i < minSize; ++i)
    c.push_back(a[i] + b[i]);

添加两个不同大小的矢量：最佳运行时间和最佳内存管理

2 个答案: