归并排序和选择排序的计数操作答案

【问题标题】：Counting Operations of Merge Sort and Selection Sort归并排序和选择排序的计数操作
【发布时间】：2012-06-19 10:27:34
【问题描述】：

我想比较排序算法合并排序和选择排序的操作计数，但我在确定哪些操作要计算哪些不计算时遇到了一些问题..

这是我的实现。我认为我正在以正确的方式计算选择排序的操作，但我不知道合并排序：

选择排序：

public class SelectionSort {
private int exchanges, comparisons;

public void selectionSort(int[] x) {    
    for (int i=0; i<x.length-1; i++) {
        for (int j=i+1; j<x.length; j++) {
            if (x[i] > x[j]) 
            {
                //... Exchange elements
                int temp = x[i];
                x[i] = x[j];
                x[j] = temp;
                exchanges++;
            }
            comparisons++;
        }
    }
    System.out.println("SelSort_Exchanges: "+exchanges);
    System.out.println("SelSort_Comparisons: "+comparisons);
    System.out.println("SelSort_Operations: "+(exchanges+comparisons));
}
}

如果我放入一个 10 int 的数组，我会得到：

SelSort_Comparisons: 45
SelSort_Exchanges: 27
SelSort_Operations: 72

对我来说似乎是正确的，但现在用于合并排序：

public class Mergesort {
private int[] numbers;
private int[] helper;

private int number;
private int comparisons, exchanges;

public void sort(int[] values) {
    this.numbers = values;
    number = values.length;
    this.helper = new int[number];
    mergesort(0, number - 1);
    System.out.println("MerSort_Comparisons "+comparisons);
    System.out.println("MerSort_Exchanges "+exchanges);
    System.out.println("MerSort_Operations "+(comparisons+exchanges));
    System.out.println();
}

private void mergesort(int low, int high) {
    // Check if low is smaller then high, if not then the array is sorted
    if (low < high) 
    {
        // Get the index of the element which is in the middle
        int middle = (low + high) / 2;
        // Sort the left side of the array
        mergesort(low, middle);
        // Sort the right side of the array
        mergesort(middle + 1, high);
        // Combine them both
        merge(low, middle, high);
    }
}

private void merge(int low, int middle, int high) {

    // Copy both parts into the helper array
    for (int i = low; i <= high; i++) {
        helper[i] = numbers[i];
        exchanges++;
    }
    int i = low;
    int j = middle + 1;
    int k = low;
    // Copy the smallest values from either the left or the right side back
    // to the original array
    while (i <= middle && j <= high) {
        if (helper[i] <= helper[j]) {
            numbers[k] = helper[i];
            i++;
            exchanges++;
        } else {
            numbers[k] = helper[j];
            j++;
            exchanges++;
        }
        k++;
        comparisons++;

    }
    // Copy the rest of the left side of the array into the target array
    while (i <= middle) {
        numbers[k] = helper[i];
        exchanges++;
        k++;
        i++;
    }
}   
}

现在我明白了

MerSort_Comparisons 22
MerSort_Exchanges 61
MerSort_Operations 83

结果，但我不知道它是否正确。比较的结果对我来说似乎是正确的，但如果我以 20 个数组为例，它似乎不再正确。

谁能帮我解决这个问题并告诉我我必须将比较和交换增量放在哪里？

提前致谢！ :)

【问题讨论】：

一个有 10 个元素的数组很难很好地说明算法的性能。为了更好地了解它们在不同输入下的表现，请尝试比较更大的数组（例如 1000 个）元素，各种风格：随机、已排序、反转等。

标签： java algorithm sorting mergesort

【解决方案1】：

最简单的方法是创建两个方法，Compare 和Swap，并在其中增加计数器。无论您实现什么sorting algorithm，它都应该只使用这些方法与数组交互。

另外，this page 可以帮助您直观地分析不同的排序算法。

【讨论】：