Java似乎比C++；。为什么？ 导言： 使用两种相同的合并算法，测试了C++（使用Visual Studio C++ 2010 Express）与java（使用NETBeaS 7）的执行速度。我推测C++执行至少会稍微快一些，但是测试显示C++执行速度比java执行慢4到10倍。我相信我已经为C++设置了所有的速度优化，并且我作为发布而不是调试发布。为什么会出现这种速度差异 代码： 爪哇： 公共类性能测试1 { /** *使用合并排序算法对数组进行排序 *@param array要排序的数组 *@返回已排序的数组 */ 公共静态无效排序（双[]数组） { 如果（array.length>1） { 国际中心； 双[]左； 双[]右； int-arrayPointer=0； int leftPointer=0； int rightPointer=0； 中心=（整数）数学层（（数组长度）/2.0）； 左=新双[中心]； 右=新双精度[array.length-中心]； System.arraycopy（数组，0，左，0，左。长度）； System.arraycopy（数组、中心、右侧、0、右侧、长度）； 排序（左）； 排序（右）； while（（leftPointer新< /COD>需要手动干预来释放内存。每一次递归都会泄漏内存。我建议使用 STD:：vector < /C> >，因为它管理所有内存和代码>迭代器，迭代器< /C>构造函数甚至会复制（并且可能比你的for循环更好地优化）。.这几乎可以肯定是您的性能差异的原因 爪哇中使用 ARAYPrime，但不要在C++中使用库设施（ STD:：复制< /代码>），但如果使用矢量< /代码>，也不重要。 Nit：在同一行上声明和初始化变量，在您第一次需要它们的时候，而不是在函数的顶部 如果允许您使用部分标准库，std:：merge可以替代您的合并算法

我不知道java为什么在这里会快得多。 我将它与内置的array.sort（）进行了比较，速度又快了4倍（它不创建任何对象）

通常情况下，如果有一个测试中Java速度更快，那是因为Java更擅长于删除不起任何作用的代码

也许您可以使用

memcpy

，而不是在末尾使用循环。

一些东西

Java是高度优化的，一旦代码执行完毕，JIT编译器就会以本机的方式执行代码

Java中System.arraycopy的执行速度要比简单地一次复制一个元素快得多。尝试用memcpy替换此副本，您将看到它的执行速度要快得多

编辑：

---

看看这个帖子：

从一开始你试过使用<代码> STD:：排序< /COD>（或<代码> STD:：Stable排序> <代码> >，以获得C++中的基线性能？

我不能评论java代码，但是C++代码：

<> LI>与java不同，C++中的代码>新< /COD>需要手动干预来释放内存。每一次递归都会泄漏内存。我建议使用<代码> STD:：vector < /C> >，因为它管理所有内存和代码>迭代器，迭代器< /C>构造函数甚至会复制（并且可能比你的for循环更好地优化）。.这几乎可以肯定是您的性能差异的原因 <>爪哇中使用<代码> ARAYPrime<代码>，但不要在C++中使用库设施（<代码> STD:：复制< /代码>），但如果使用<代码>矢量< /代码>，也不重要。
• Nit：在同一行上声明和初始化变量，在您第一次需要它们的时候，而不是在函数的顶部
• 如果允许您使用部分标准库，

  std:：merge

  可以替代您的合并算法

编辑：如果你真的使用say

delete left；

来清理内存，那可能是你的问题。正确的语法应该是

delete[]left；

来释放数组。

你的版本泄漏了太多内存，因此计时毫无意义。 我确信这段时间花在了内存分配器上。
重写它使用标准C++对象进行内存管理STD:：vector，看看会发生什么。 P>个人看来，我仍然希望java版本能够获胜（因为）JIT允许机器特定的优化，C++虽然可以进行机器特定的优化，但是它只会做一般的架构优化（除非你提供了精确的架构标志）。

• 注意：不要忘记在启用优化的情况下编译

正在清理您的C++:
我还没有尝试用C++风格< /P>做一个好的合并排序（只是重新编写）。

void sort1(std::vector<double>& data)
{
    if(data.size() > 1)
    {
        std::size_t         centre    = data.size() / 2;
        std::size_t         lftSize   = centre;
        std::size_t         rhtSize   = data.size() - lftSize;

        // Why are we allocating new arrays here??
        // Is the whole point of the merge sort to do it in place?
        // I forget bbut I think you need to go look at a knuth book.
        //
        std::vector<double> lft(data.begin(),           data.begin() + lftSize);
        std::vector<double> rht(data.begin() + lftSize, data.end());

        sort1(lft);
        sort1(rht);
        std::size_t dataPointer   = 0;
        std::size_t lftPointer    = 0;
        std::size_t rhtPointer    = 0;

        while((lftPointer < lftSize) && (rhtPointer < rhtSize))
        {                                                                               
            data[dataPointer++] = (lft[lftPointer] <= rht[rhtPointer])
                                    ?  lft[lftPointer++]
                                    :  rht[rhtPointer++];
        }
        std::copy(lft.begin() + lftPointer, lft.end(), &data[dataPointer]);
        std::copy(rht.begin() + rhtPointer, rht.end(), &data[dataPointer]);
    }
}

void sort1（标准：：向量和数据）
{
如果（data.size（）>1）
{
std:：size\u t center=data.size（）/2；
标准：尺寸=中心；
std:：size\u t rhtSize=data.size（）-lftSize；
//我们为什么在这里分配新阵列？？
//合并排序的全部要点是否到位？
//我忘了，但我想你需要
#include <iostream>
#include <windows.h>
using namespace std;

//Mergesort
void sort1(double *data,int size)
{
if(size > 1)
{
    int centre;
    double *left;
    int leftSize;
    double *right;
    int rightSize;
    int dataPointer = 0;
    int leftPointer = 0;
    int rightPointer = 0;

    centre = (int)floor((size) / 2.0);
    leftSize = centre;
    left = new double[leftSize];
    for(int i = 0;i < leftSize;i += 1)
    {
        left[i] = data[i];
    }
    rightSize = size - leftSize;
    right = new double[rightSize];
    for(int i = leftSize;i < size;i += 1)
    {
        right[i - leftSize] = data[i];
    }

    sort1(left,leftSize);
    sort1(right,rightSize);

    while((leftPointer < leftSize) && (rightPointer < rightSize))
    {
        if(left[leftPointer] <= right[rightPointer])
        {
            data[dataPointer] = left[leftPointer];
            leftPointer += 1;
        }
        else
        {
            data[dataPointer] = right[rightPointer];
            rightPointer += 1;
        }
        dataPointer += 1;
    }
    if(leftPointer < leftSize)
    {
        for(int i = dataPointer;i < size;i += 1)
        {
            data[i] = left[leftPointer++];
        }
    }
    else if(rightPointer < rightSize)
    {
        for(int i = dataPointer;i < size;i += 1)
        {
            data[i] = right[rightPointer++];
        }
    }
            delete left;
            delete right;
}
}

void main()
{
//Number of elements to sort
int arraySize = 1000000;

//Create the variables for timing
LARGE_INTEGER start; //Starting time
LARGE_INTEGER end; //Ending time
LARGE_INTEGER freq; //Rate of time update
double duration; //end - start
QueryPerformanceFrequency(&freq); //Determinine the frequency of the performance counter (high precision system timer)

//Build array
double *temp2 = new double[arraySize];
QueryPerformanceCounter(&start);
srand((int)start.QuadPart);
for(int i = 0;i < arraySize;i += 1)
{
    double randVal = rand() % 10000;
    temp2[i] = randVal;
}

//Run performance test
QueryPerformanceCounter(&start);
sort1(temp2,arraySize);
QueryPerformanceCounter(&end);
    delete temp2;

//Output performance test results
duration = (double)(end.QuadPart - start.QuadPart) / (double)(freq.QuadPart);
cout << "Duration: " << duration << endl;

//Dramatic pause
system("pause");
}

void sort1(std::vector<double>& data)
{
    if(data.size() > 1)
    {
        std::size_t         centre    = data.size() / 2;
        std::size_t         lftSize   = centre;
        std::size_t         rhtSize   = data.size() - lftSize;

        // Why are we allocating new arrays here??
        // Is the whole point of the merge sort to do it in place?
        // I forget bbut I think you need to go look at a knuth book.
        //
        std::vector<double> lft(data.begin(),           data.begin() + lftSize);
        std::vector<double> rht(data.begin() + lftSize, data.end());

        sort1(lft);
        sort1(rht);
        std::size_t dataPointer   = 0;
        std::size_t lftPointer    = 0;
        std::size_t rhtPointer    = 0;

        while((lftPointer < lftSize) && (rhtPointer < rhtSize))
        {                                                                               
            data[dataPointer++] = (lft[lftPointer] <= rht[rhtPointer])
                                    ?  lft[lftPointer++]
                                    :  rht[rhtPointer++];
        }
        std::copy(lft.begin() + lftPointer, lft.end(), &data[dataPointer]);
        std::copy(rht.begin() + rhtPointer, rht.end(), &data[dataPointer]);
    }
}

void mergeSort(double* begin, double* end, double* tmp)
{
    if (end - begin <= 1)
    {   return;
    }

    std::size_t size    = end - begin;
    double*     middle  = begin +  (size / 2);

    mergeSort(begin, middle, tmp);
    mergeSort(middle, end, tmp);

    double* lft    = begin;
    double* rht    = middle;
    double* dst    = tmp;
    while((lft < middle) && (rht < end))
    {
        *dst++  = (*lft < *rht)
                        ? *lft++
                        : *rht++;
    }
    std::size_t count   = dst - tmp;
    memcpy(begin,          tmp, sizeof(double) * count);
    memcpy(begin + count,  lft, sizeof(double) * (middle - lft));
    memcpy(begin + count,  rht, sizeof(double) * (end    - rht));
}

void sort2(std::vector<double>& data)
{
    double*     left    = &data[0];
    double*     right   = &data[data.size()];

    std::vector<double> tmp(data.size());

    mergeSort(left,right, &tmp[0]);
}

Java code:            7.13
Java Arrays.sort:     0.93

32 bits
C++ code:             3.57
C++ std::sort         0.81

64 bits
C++ code:             2.77
C++ std::sort         0.76
#include <cstdio>
#define N 500001

int a[N];
int x[N];
int n;

void merge (int a[], int l, int r)
{
    int m = (l + r) / 2;
    int i, j, k = l - 1;
    for (i = l, j = m + 1; i <= m && j <= r;)
        if (a[i] < a[j])
            x[++k] = a[i++];
        else
            x[++k] = a[j++];
    for (; i <= m; ++i)
        x[++k] = a[i];
    for (; j <= r; ++j)
        x[++k] = a[j];
    for (i = l; i <= r; ++i)
        a[i] = x[i];
}

void mergeSort (int a[], int l, int r)
{
    if (l >= r)
        return;
    int m = (l + r) / 2;
    mergeSort (a, l, m);
    mergeSort (a, m + 1, r);
    merge (a, l, r);
}

int main ()
{
    int i;
    freopen ("algsort.in", "r", stdin);
    freopen ("algsort.out", "w", stdout);
    scanf ("%d\n", &n);
    for (i = 1; i <= n; ++i)
        scanf ("%d ", &a[i]);
    mergeSort (a, 1, n);
    for (i = 1; i <= n; ++i)
        printf ("%d ", a[i]);
    return 0;
}