為什么在這種排序算法的實現中，向量比數組慢得多？

Question

toBeSorted一個實現是使用vector從參數toBeSorted復制數據。 通過更改它，分配一個常規數組並“手動”復制每個值，程序的執行速度會更快（底部的詳細信息）。

我預計會有一些開銷，但差異的規模讓我感到驚訝。 我認為構造一個向量幾乎不會比用new分配一個數組慢。

代碼（我刪除了實際合並以最小化示例）：

#include <iostream>
#include <vector>
#include <time.h>

using namespace std;

#define USE_VECTORS

void Merge(vector<int>& toBeSorted, int left, int middle, int right) {
  int rightPartSize = (-1) * (middle - right);
  int leftPartSize = (middle - left) + 1;

#ifdef USE_VECTORS

  vector<int> leftPart{toBeSorted.begin() + left,
                            toBeSorted.begin() + left + leftPartSize};

  vector<int> rightPart{toBeSorted.begin() + middle + 1,
                            toBeSorted.end()};
#else

  int* leftPart = new int[leftPartSize];
  for (int i = 0; i < leftPartSize; i++) {
    leftPart[i] = (toBeSorted[left + i]);
  }

  int* rightPart = new int[rightPartSize];
  for (int i = 0; i < rightPartSize; i++) {
    rightPart[i] = (toBeSorted[middle + i + 1]);
  }

  delete[] leftPart;
  delete[] rightPart;
#endif
}

void MergeSort(vector<int>& toBeSorted, int left, int right) {
  if (left < right) {
    int middle = (left + right) / 2;
    MergeSort(toBeSorted, left, middle);
    MergeSort(toBeSorted, middle + 1, right);
    Merge(toBeSorted, left, middle, right);
  }
}

int main() {

  const int SIZE = 100000;
  std::vector<int> x(SIZE, 0);

  clock_t t_start = clock();
  MergeSort(x, 0, int(x.size()) - 1);
  clock_t t_end = clock();

  double elapsedTime = (t_end - t_start) / (double)CLOCKS_PER_SEC;
  cout << "Time: " << elapsedTime << endl;

  return 0;
}

在reextester上運行它，我得到的時間大約是 1.2 秒。
取消注釋#define USE_VECTORS以查看數組版本的時間。 為此，我看到了 ~0.009 秒。

Answer 1

計算rightPartSize代碼與您創建rightPart向量的方式rightPart 。 您可以通過添加以下語句輕松檢查它：

if( static_cast<size_t>( rightPartSize ) != rightPart.size() ) 
      cout << rightPartSize << " != " << rightPart.size() << endl;

在創建rightPart之后：

1 != 99999
1 != 99997
2 != 99998
1 != 99995
1 != 99994
3 != 99996
1 != 99992
1 != 99991
1 != 99989
1 != 99988
3 != 99990
6 != 99993
1 != 99986
1 != 99985
1 != 99983
...

因此，vector 完成的工作量遠遠大於您使用動態數組所做的工作量。