Question

我在Java和C ++中实现了Merge Sort，我尝试尽可能地实现它们。两种算法都有效，我多次测试它们。问题是我的Java实现比我的C ++快得多 - 实现，我想知道为什么。我无法相信Java会更快，所以我猜我在其中一个实现中犯了一个错误。为了测量运行时间，我创建了一个类＆＃34; Person＆＃34;它有两个String-Attributes（forename，lastname）。在C ++中，我使用了std::vector<Person*>，而在Java中，我使用了ArrayList<Person>。另外，我在C ++中重载operator<来比较两个人（比较姓氏，如果相等则比较名字）。在Java中，我实现了接口Comparable<Person>来比较两个人。

你能在我的代码中找到错误，或者为什么Java会更快或者C ++会更慢？任何帮助将不胜感激。

我的Java代码：

public void mergeSort(List<T> list) {
    if (list.size() <= 1) {
        return;
    }

    int subLength = (int) (list.size() / 2);
    List<T> first = new ArrayList<T>(list.subList(0, subLength));
    List<T> second = new ArrayList<T>(list.subList(subLength, list.size()));


    mergeSort(first);
    mergeSort(second);

    merge(first, second, list);
    return;
}

private void merge(List<T> first, List<T> second, List<T> result) {
    int firstPos = 0, secondPos = 0, resultPos = 0;

    while (firstPos < first.size() && secondPos < second.size()) {
        if (first.get(firstPos).compareTo(second.get(secondPos)) < 0) {
            result.set(resultPos, first.get(firstPos));
            firstPos++;
        } else {
            result.set(resultPos, second.get(secondPos));
            secondPos++;
        }
        resultPos++;
    }

    for (int i = firstPos; i < first.size(); i++) {
        result.set(resultPos, first.get(i));
        resultPos++;
    }
    for (int i = secondPos; i < second.size(); i++) {
        result.set(resultPos, second.get(i));
        resultPos++; 
    }
}

我的C ++代码：

注意：我使用了两个模板方法，使mergesort可用于Person和Person*。

template<typename T>
    T * ptr(T & obj) { return &obj; } 

    template<typename T>
    T * ptr(T * obj) { return obj; }


void mergeSort(std::vector<T> &list) {
        if (list.size() <= 1) {
            return;
        }

        int subLength = (int)(list.size() / 2);
        std::vector<T> first(list.begin(), list.begin() + subLength);
        std::vector<T> second(list.begin() + subLength, list.end());

        mergeSort(first);
        mergeSort(second);

        merge(first, second, list);

    }
void merge(const std::vector<T> &first, const std::vector<T> &second, std::vector<T> &result) {
        int firstPos = 0, secondPos = 0, resultPos = 0;
        while (firstPos < first.size() && secondPos < second.size()) {
            if (*ptr(first[firstPos]) < *ptr(second[secondPos])) {
                result[resultPos] = first[firstPos];
                firstPos++;
            }
            else {
                result[resultPos] = second[secondPos];
                secondPos++;
            }
            resultPos++;
        }

        for (int i = firstPos; i < first.size(); i++) {
            result[resultPos] = first[i];
            resultPos++;
        }
        for (int i = secondPos; i < second.size(); i++) {
            result[resultPos] = second[i];
            resultPos++;
        }
    }

编辑1和2：

我的设置配置：

我使用了一百万，一千万和两千万人来测试这些实现。我测试它的人数并不重要，Java总是更快。

我用以下方式测试它：我创建人并初始化我的MergeSort - 类。然后我开始测量，然后调用我的mergeSort - 方法。分拣完成后，我停止测量。（在时间测量之后发生删除）。对于Java中的时间测量，我使用System.nanoTime()，而在C ++中我使用chrono::high_resolution_clock::time_point

当然我在＆＃34; Release＆＃34; -Mode（优化：O2，更快的代码首选）中编译了C ++。

My Test-PC：

Intel i5 2500
8GB DDR3 RAM
Windows 10教育

EDIT3：

有一件事我忘了提及。我以通用的方式实现了算法，以便使用简单的数据类型和对象。当我在Java中使用std::vector<int>和ArrayList<Integer>时，我的C ++实现要快得多。我的第一次尝试是使用std::vector<Person>，但速度更慢。所以我的猜测是它制作了深层副本而不是浅层副本，这就是我切换到Person*的原因，因为我认为在复制时只会复制指针。

Answer 1

TL; DR - Java版本的阵列复制次数较少。

ArrayList传递Collection时Collection.toArray() Arrays.copyOf使用ArrayList，如果需要，可选toArray()。 ~~如果是if (elementData.getClass() != Object[].class)，则无需复制 - List.subList返回对基础数组的引用~~。

另请注意，ArrayList将导致数组不再被复制。

ArrayList对象上的ArrayList.toArray不复制任何底层数组，它只返回原始支持的JSONArray，但仅限于所需的元素。

结果 - 在可能的情况下，整个机制使用实际只是引用原始数组的子列表 - 不需要复制。

不太熟悉C ++，但我怀疑有很多数组复制和分配正在进行，而不需要由Java完成。

ADDED - 正如@ThomasKläger正确地指出的那样，for(int i=0;i<2;i++) { JsonArray jsonarray = new JsonArray(); JsonObject pacs_obj = new JsonObject(); pacs_obj.addProperty("pac_id", "1235"); jsonarray.add(pacs_obj); String new_catid = "1"; if (datafromdb.containsKey(new_catid)) { datafromdb.get(new_catid).add(jsonarray); } else{ datafromdb.put(new_catid, jsonarray); } }实际上确实返回了阵列的防御性副本 - 所以我上面错了。

Answer 2

我看到的1个^st中的一个在你的陈述中：

在时间测量之后正在进行删除

您在谈论删除Person个对象时，您显然没有谈到容器，例如C ++正在创建的first和second清理堆栈：

std::vector<T> first(list.begin(), list.begin() + subLength);
std::vector<T> second(list.begin() + subLength, list.end());

虽然Java在堆上创建它们并且没有清理它们直到它到达它（所以在你停止计时之后）：

List<T> first = new ArrayList<T>(list.subList(0, subLength));
List<T> second = new ArrayList<T>(list.subList(subLength, list.size()));

因此，您需要使用容器清理和不使用Java的C ++进行计时。

我必须在这里问一下，编写自己的合并排序的重点是什么？最好的Java和C ++代码将使用该语言已经提供的排序算法。如果您正在寻找至少计算优化算法的时间。

此外，我不会将大量工作投入到时间比较中。 C ++ 将更快，一般来说写作也会更多。如果速度足够重要，你可以打扰时间，你可能想要使用C ++。如果开发时间为王，那么您将希望使用Java。

为什么我的Java Merge-Sort比我的C ++实现更快？

2 个答案: