0

我正在寻找一种运行时高效的小工具，它可以（成对）添加存储在两个整数向量（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-> (0)(12)(0)(0)(123)(12)

vector<int> b-> (305)(10)(3)(4)(8201)(230)(0)(0)(0)

vector<int> c-> (305)(22)(3)(4)(8324)(242)(0)(0)(0)

4

2 回答 2

3

您可以使用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>）并将结果存储在第三个范围（第四个参数）中。

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

于 2013-08-01T20:12:17.617 回答
0 
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]);
于 2013-08-01T20:08:45.493 回答