Java 合并排序比较？

我认为在返回比较次数的merge sort 2类/方法中，使用merge sort的比较次数不正确。合并排序2类似于合并排序，但只返回比较的数量。下面是我的演示，我有一个4个整数的数组{2,55,1,45}，当我运行程序时，它返回8个比较。有谁能证实这是否正确，或者我做错了什么

我的演示：

    ArrayInts[] myInts2 = new ArrayInts[4];

    myInts2[0] = new ArrayInts(2);
    myInts2[1] = new ArrayInts(55);
    myInts2[2] = new ArrayInts(1);
    myInts2[3] = new ArrayInts(45);

    MergeSort.mergeSort(myInts2, 0, 3);

    System.out.println("Sorted using Merge Sort: ");


    for (int index = 0; index < myInts2.length; index++) {
        System.out.println(myInts2[index]);
    }

    System.out.println("Number of comps using Merge Sort: " + MergeSort2.mergeSort2(myInts2, 0, 3));
    System.out.println(" ");

ArrayInts[]myInts2=新的ArrayInts[4]；
myInts2[0]=新数组（2）；
myInts2[1]=新阵列（55）；
myInts2[2]=新阵列（1）；
myInts2[3]=新阵列（45）；
MergeSort.MergeSort（myInts2，0，3）；
System.out.println（“使用合并排序进行排序：”）；
for（int index=0；index

我的合并排序2类/方法：

 public class MergeSort2 {
 private static long comp=0;

public static <T extends Comparable<? super T>> long mergeSort2(T[] data, int min, int max) {
    T[] temp;
    int index1, left, right;


    //return on list of length one

    if (min == max) {
        return comp;
    }

    //find the length and the midpoint of the list

    int size = max - min + 1;
    int pivot = (min + max) / 2;
    temp = (T[]) (new Comparable[size]);

    mergeSort2(data, min, pivot); //sort left half of list
    mergeSort2(data, pivot + 1, max); //sort right half of list

    //copy sorted data into workspace

    for (index1 = 0; index1 < size; index1++) {
        temp[index1] = data[min + index1];
    }

    //merge the two sorted lists

    left = 0;
    right = pivot - min + 1;
    for (index1 = 0; index1 < size; index1++) {
        comp++;
        if (right <= max - min) {

            if (left <= pivot - min) {

                if (temp[left].compareTo(temp[right]) > 0) {

                    data[index1 + min] = temp[right++];
                } else {
                    data[index1 + min] = temp[left++];
                }
            } else {
                data[index1 + min] = temp[right++];
            }
        } else {
            data[index1 + min] = temp[left++];
        }
    }


    return comp;

    }

    }

公共类MergeSort2{
专用静态长comp=0；
publicstatic您得到的是8，因为无论是否存在比较，每次执行合并循环时都会递增

如果你改变

for (index1 = 0; index1 < size; index1++) {
    comp++;
    if (right <= max - min) {

        if (left <= pivot - min) {

第二次调用sort将使用已排序的数据而不是未排序的数据，因此
不同的结果。对数组进行排序可以修改数组，以便调用多个排序
时间可以得到不同的行为。
您显示的比较次数对于您给我们的方法是正确的。当一个长度为
4
的数组被传递到您给我们的方法中时，
comp++；
行被调用8次。让我解释一下

首先，
pivot=1
。这些行进行两个递归调用：

mergeSort2(data, min, pivot); //sort left half of list
mergeSort2(data, pivot + 1, max); //sort right half of list

在每一个调用完成两个额外的嵌套递归调用后，它们继续将
comp
增加2，因为for循环运行的迭代次数等于
size
。在这两个调用中，
size=2
，因此在调用一后，
comp=2
，在调用二后，
comp=4
。
然而，这些递归调用中的每一个又进行了两次递归调用，因为在这些调用中的每一次，
min==max
，该方法返回
return comp；
，从未到达increment
comp
的行

最后，在两个初始递归方法调用返回后，会再次调用递增的for循环
comp
，因为在初始调用中，
size=4
。因此，
comp=4+4
，等于8

如果这让人困惑，我将用每次调用
mergesort2（）
的（
min
，
max
）来说明我的答案

希望我在这里讲清楚了

edit1:BevynQ的答案是正确的。我的答案更关注代码返回8的原因，而他的答案则关注排序方法错误计算比较的原因

edit2:我将您的代码直接复制并粘贴到我的编辑器中，并添加了一行更改BevynQ。我的代码按预期工作，我看不到与您相同的结果。可能是意外更改了其他内容？
一些示例数组（及其比较次数）是什么我应该使用来测试我的类是否返回了正确数量的比较？例如test{0,1,2,3,4,5}它应该返回x个比较量。只是为了再次检查，所以我只需要一个comp++；在我的类中，对吗？你需要有comp++来进行比较，所以只有一个comp++；然后对吗？其他comp++；会去哪里？好的，所以我根据你的答案更正了我的代码，当我尝试测试[0,2,1,3]，它返回4个比较，而不是5个比较。我做错了什么/遗漏了什么？谢谢。如果你能帮我解决另一个问题，我必须检查我对第一个答案的最新评论。我复制并粘贴了你的代码直接到我的编辑器中，并添加了一行更改BevynQ。我的代码按预期工作，我没有看到相同的结果结果是这样的。可能是其他东西被意外更改了？你能发布你拥有的吗？因为它对我不起作用，我怀疑它对你也起作用。我检查了所有内容，似乎都是正确的，但结果是错误的。你正在测试[0,4,1,5,2,6,3,7]？它为我返回12个comps。它应该返回16个comps。是的，我已经测试过了[0,4,1,5,2,6,3,7]。我看到了16次比较的返回。唯一的区别是，因为您没有提供
ArrayInts
的实现，所以我只使用整数。但是，只要
ArrayInts.compareTo（）
正确实现，这应该不会影响比较的数量。
MergeSort.mergeSort(myInts2, 0, 3);

System.out.println("Sorted using Merge Sort: ");


for (int index = 0; index < myInts2.length; index++) {
    System.out.println(myInts2[index]);
}

System.out.println("Number of comps using Merge Sort: " + MergeSort2.mergeSort2(myInts2, 0, 3));
System.out.println(" ");

int result = MergeSort.mergeSort(myInts2, 0, 3);

System.out.println("Sorted using Merge Sort: ");


for (int index = 0; index < myInts2.length; index++) {
    System.out.println(myInts2[index]);
}

System.out.println("Number of comps using Merge Sort: " + result);
System.out.println(" ");

public static void main(String[] args) {
    Integer[] myInts2 = new Integer[4];

    myInts2[0] = new Integer(0);
    myInts2[1] = new Integer(2);
    myInts2[2] = new Integer(1);
    myInts2[3] = new Integer(3);

    System.out.println(new MergeSort2().mergeSort2(myInts2, 0, 3)); // will output 5
    System.out.println(new MergeSort2().mergeSort2(myInts2, 0, 3)); // will output 4
}

mergeSort2(data, min, pivot); //sort left half of list
mergeSort2(data, pivot + 1, max); //sort right half of list

/* 1. */ (min=0, max=3) -> size=4, comp = comp + 4;
/* 2. */     (min=0, max=1) -> size=2, comp = comp + 2;
/* 3. */         (min=0, max=0) -> size=0, comp = comp + 0;
/* 4. */         (min=1, max=1) -> size=0, comp = comp + 0;
/* 5. */     (min=2, max=3) -> size=2, comp = comp + 2;
/* 6. */         (min=2, max=2) -> size=0, comp = comp + 0;
/* 7. */         (min=3, max=3) -> size=0; comp = comp + 0;

/* TOTAL. */  comp = 0 + 0 + 2 + 0 + 0 + 2 + 4; comp = 8