Question

我正在尝试找到将两个数组附加到一起的最快方法我知道这是一个简单的问题。但我需要一种非常快速的方法来使用库函数

以下是我的代码，它没有任何库函数

  #include <iostream>
    #include <algorithm>

    using namespace std;

    int main()
    {
       int a[] = {1,2,3,4,5};
       int b[] = {6,7,8,9,10};
       int c[10];

       for(int i=0; i<5; i++)
       {
          c[i] = a[i];   
       }

       for(int i=5; i<10; i++)
       {
          c[i] = b[i-5];   
       }


       for(int i=0; i<10; i++)
       {
          cout << c[i] << endl;  
       }


}

什么是更有效的方式？

Answer 1

首先，我认为你的循环很好。如果你愿意，你可以尝试将它们合并到一个循环中，为你提供任何加速，因为你只需要一半的迭代次数：

for (int i = 0; i < 5; ++i) {
    c[i] = a[i];
    c[i+5] = b[i];
}

但衡量这一点，绝不保证更快。如果阵列总是那么小，那么性能上的任何差异都是不太可能的。

如果你想使用<algorithm>库（我喜欢这样做以便于阅读，但在你的情况下，循环足够短），你可以这样做：

std::copy(a, a+5, c);
std::copy(b, b+5, c+5);

它很可能不比循环快，但看起来更清洁IMO。当数据量变大时，它实际上可以通过以优化的方式实现加速，但一如既往地测量它。

但我会远离memcpy。它不适用于所有类型，并且不提供（或不应提供任何）优于std::copy的优势。

作为最后一点，请考虑使用现代std::array替换原始C阵列。这里的一个优点是您可以使用=复制它，以及fill和size等一些简洁的成员函数。

Answer 2

我认为对于基本类型，使用标题memcpy中声明的标准C函数<cstring>会更有效

例如

#include <cstring>

//,,,

int a[] = {1,2,3,4,5};
int b[] = {6,7,8,9,10};
int c[10];

std::memcpy( c, a, sizeof( a ) );
std::memcpy( c + 5, b, sizeof( b ) );

如果您想使用标准算法，那么您可以编写

#include <algorithm>

//...

std::copy_n( b, 5, std::copy_n( a, 5, c ) );

Answer 3

如果您真的想使用<algorithm>，则std::copy。这个单线程依赖于内部函数调用将迭代器（在这种情况下为指针）返回到它停止的位置这一事实。然后外部函数调用继续复制b数组。

std::copy(b, b+5, std::copy(a, a+5, c));

它仍然是两个循环和O（n）。

Answer 4

您不需要<algorithm>。这对我来说似乎很好，在O（n）复杂度下工作就像下面的选择：

   for(int i=0; i<10; i++)
   {
      if(i < 5){
          c[i] = a[i];
      }
      else{
          c[i] = b[i-5];   
      }
   }

Answer 5

这可能是最快的。使用vector代替香草arrays

#include <vector>

   int main()
    {
     vector<T> one;
     vector<T> two;
     //populate the vector

     //This is the fastest it could get.
     one.insert(one.end(), two.begin(), two.end());
     return 0;
    }

Answer 6

如果你如此关注你提供的算法的性能 - 它具有O（n）复杂度 - 那么我想知道你是否首先选择了正确的算法。换句话说，如果你需要比你正在做的更快，那么你可能首先做错了。

话虽这么说，将两个数组复制到第三个不同的数组不能比线性复杂性更好。当然，复杂性在很大程度上是一个学术问题。真正重要的是速度。也就是说，如果您对“更好”的定义意味着“比运行得比O（n）算法的实现速度快的O（n * n）算法的实现更快”，那么您的定义会更好。确保复制的内容快速复制。

您已加入<algorithm>，但不使用它。我建议你应该这样做。本身不是性能，而是可维护性。标准保证算法复杂性的事实是一个好处，并且您在编写代码时没有这样的保证，除了测试它并在编写时要小心。所以我更喜欢：

std::merge (std::begin (a), std::end (a), std::begin (b), std::end (b) , std::begin (c));

假设a和b实际上是排序的。实际上，不使用C风格的数组会更好。

std::vector <int> a;
std::vector <int> b;
std::vector <int> c;
// ...
std::merge (std::begin (a), std::end (a), std::begin (b), std::end (b) , std::begin (c));

为了推动关于可维护性的观点，请注意实际代码（使用merge）如何更改，即使我更改了它所处理的容器类型。

Answer 7

这对我有用。在CINT中，但也应该编译。

...
  int a[] = {1,2,3,4,5};
       int b[] = {6,7,8,9,10};
       int c[10];

       memcpy( &c[0], &a, sizeof(a) );
       memcpy( &c[5], &b, sizeof(b) );

       for(int i=0; i<10; i++)
       {
          cout << c[i] << endl;  
       }
...

很好，有多少答案出现了。这个也适用于纯C。

附加两个数组（连接两个数组）C ++的最快方法

7 个答案: