气泡，选择，插入和快速排序中的交换和比较次数

Question

我已经用Java实现了所有四种排序算法。 只是为了解决问题，我决定查看每种算法中的交换次数和比较次数。 对于大小为20的随机数组，这是我的结果

气泡排序：87次互换，87次比较

插入排序：87个交换，87个比较

选择排序：19个交换，29个比较

快速排序：11940个交换，我什至不知道从哪里计算比较

为什么气泡排序和选择排序相同？ 我的意思是看代码我几乎可以看到它。 循环几乎相同，我只是希望有人为我指出。

我可以看到为什么选择排序的交换次数最少

快速排序对我来说是个谜（该死的您递归）。 我认为这就是交换次数疯狂的原因。 为什么我的执行速度这么慢？ 其他三个完成之前。

*****代码-让我知道是否缺少任何内容**

交换对于所有三个实施都是相同的

private void swap(int firstIndex, int secondIndex) {
    int temp = array[firstIndex];
    array[firstIndex] = array[secondIndex];
    array[secondIndex] = temp;
}

气泡

public void sort() {
    for(int out = nElements-1; out > 1; out--) {// outer backwards loop
        for(int in = 0; in < out; in++) { // inner forward loop 
            if(array[in] > array[in+1]) {
                swap(in, in + 1);
                totalSwaps++;
                totalComparisons++;
            }
        }
    }
}

选择

public void sort() {
    for (int i = 0; i < nElements-1; i++) {
        int currentMinIndex = i;
        for (int j = i + 1; j < nElements; j++)
            if (array[j] < array[currentMinIndex]) {
                currentMinIndex = j;
                totalComparisons++;
            }
        swap(i, currentMinIndex);
        totalSwaps++;
    }
}

插入

public void sort() {
    for(int i = 1; i < nElements; i++) {
        for(int j = i; j > 0; j--) {
            if(array[j] < array[j-1]) {
                swap(j, j - 1);
                totalSwaps++;
                totalComparisons++;
            }
        }
    }
}

快速排序

public void sort() {
    sort(this.array, 0, array.length - 1);
}
private void sort(int[] array, int left, int right) {
    if(left >= right)
        return;

    int randomIndex = new Random().nextInt(array.length);
    int pivot = array[randomIndex];

    // returns the dividing point between the left side and the right side
    int index = partition(array, left, right, pivot);

    sort(array, left, index - 1);
    sort(array, index, right);
}

private int partition(int[] array, int left, int right, int pivot) {
    while(left <= right) {
        while(array[left] < pivot)  // will break when there's an element to the left of the pivot that's greater
            left++;

        while(array[right] > pivot)  // breaks when there's an element to the right of the pivot that's less
            right--;

        if(left <= right) {
            swap(left, right);
            left++;
            right--;
            totalSwaps++;

        }

    }

    return left;  // left will be at the partition point
}

主要

import java.util.Random;


public class Sorting {

private static final int maxSize = 50;
private static int[] randomArray() {
    int[] array = new int[maxSize];
    Random random = new Random();
    random.setSeed(0);
    for(int i = 0; i < maxSize; i++)
        array[i] = random.nextInt(50);
    return array;
}

public static void main(String[] args) {

    int[] randomArr = randomArray();

    BubbleSort bubbleSort = new BubbleSort(randomArr);
    bubbleSort.display();
    bubbleSort.sort();
    bubbleSort.display();

    randomArr = randomArray();

    SelectionSort selectionSort = new SelectionSort(randomArr);
    selectionSort.sort();
    selectionSort.display();

    randomArr = randomArray();

    InsertionSort insertionSort = new InsertionSort(randomArr);
    insertionSort.sort();
    insertionSort.display();

    System.out.println("Bubble Sort: Swaps = " + bubbleSort.totalSwaps + " Comparisons = " + bubbleSort.totalComparisons);
    System.out.println("Selection Sort: Swaps = " + selectionSort.totalSwaps + " Comparisons = " + selectionSort.totalComparisons);
    System.out.println("Insertion Sort: Swaps = " + insertionSort.totalSwaps + " Comparisons = " + insertionSort.totalComparisons);


    randomArr = randomArray();

    QuickSort quickSort = new QuickSort(randomArr);
    quickSort.sort();
    quickSort.display();

    System.out.println("Quick Sort: Swaps = " + quickSort.totalSwaps);
}

}

产量

10 48 29 47 15 3 41 11 19 4 27 27 23 12 45 44 34 25 41 20  // original
3 4 10 11 12 15 19 20 23 25 27 27 29 34 41 41 44 45 47 48  // bubble
3 4 10 11 12 15 19 20 23 25 27 27 29 34 41 41 44 45 47 48  // selection
3 4 10 11 12 15 19 20 23 25 27 27 29 34 41 41 44 45 47 48  // insertion
Bubble Sort: Swaps = 87 Comparisons = 87
Selection Sort: Swaps = 19 Comparisons = 29
Insertion Sort: Swaps = 87 Comparisons = 87
3 4 10 11 12 15 19 20 23 25 27 27 29 34 41 41 44 45 47 48  // quick
Quick Sort: Swaps = 25283

Answer 1

至于如何计算操作，您总是可以考虑添加一个间接层。 例如，使用此类之类来执行和计数操作：

class Instrumentation {
    int compares = 0;
    int swaps = 0;

    boolean compareLess(int left, int right) {
        compares++;
        return left < right;
    }

    boolean compareGreater(int left, int right) {
        compares++;
        return left > right;
    }

    void swap(int[] array, int index1, int index2) {
        int temp = array[index1];

        array[index1] = array[index2];
        array[index2] = temp;

        swaps++;
    }

    void printResult(String label) {
        System.out.print(label);
        System.out.print(": Swaps = ");
        System.out.print(swaps);
        System.out.print(" Comparisons = ");
        System.out.println(compares);
    }
}

修改了足以使用该检测类计数操作的代码之后，我得到了以下结果：

Original data:
10 48 29 47 15 3 41 11 19 4 27 27 23 12 45 44 34 25 41 20 

BubbleSort: Swaps = 87 Comparisons = 189
3 4 10 11 12 15 19 20 23 25 27 27 29 34 41 41 44 45 47 48 

SelectionSort: Swaps = 19 Comparisons = 190
3 4 10 11 12 15 19 20 23 25 27 27 29 34 41 41 44 45 47 48 

InsertionSort: Swaps = 87 Comparisons = 190
3 4 10 11 12 15 19 20 23 25 27 27 29 34 41 41 44 45 47 48 

QuickSort: Swaps = 3221 Comparisons = 110575
3 4 10 11 12 15 19 20 23 25 27 27 29 34 41 41 44 45 47 48 

现在观察到，比较排序的主要特征是在最坏的情况下，它们涉及将每个元素与每个其他元素进行比较。 对于20个元素，这就是20 * 19/2 = 190个比较，这基本上是您的比较排序实现在每种情况下都会产生的结果（对于冒泡排序，则少于一个）。

实际上，在每种情况下，这都是您对Bubble和Selection排序的期望，但在一般情况下，这并不是您期望的插入排序。 那是因为您的插入排序实现存在缺陷：这种排序的前提是它依赖于中间结果（按顺序放入数组的第一部分）来减少所需的比较次数。 第一次在内部循环中进行的比较失败，因此不需要进行交换，您应该从（内部）循环中中断，因为您知道直到外部循环的下一次迭代才需要进行进一步的交换。 实施后，您的特定数据的比较次数减少到105。

比较排序之间的交换次数也很有意义：冒泡排序和插入排序都通过与相邻元素的一系列交换将每个元素从其初始位置移动到最终位置。 确实，您的实现实际上是彼此的镜像。 但是，我不准备超越这只挥手的手。

至于选择排序，是的，对于排序n个元素，它将始终执行（ n *（ n -1））/ 2个比较，并且最多进行n -1个交换（如果执行并计算自交换，则为n -1个交换） 。

然后是您的快速排序。 显然，这不是很快-确实存在严重错误。 稍微多一点的检测告诉我，递归深度下降得太大（平均约为400，而即使在最坏的情况下也不应超过n ）。 问题在于您随机选择枢轴。 无需从要排序的子数组中选择枢轴，而是从整个数组中选择它。 要解决此问题，请更换

int randomIndex = new Random().nextInt(array.length);

同

int randomIndex = left + new Random().nextInt(right + 1 - left);

这应该使您对比较和交换都有更有利的计数，但是直到您开始对更大的数组进行排序之前，您才真正注意到快速排序相对于其他排序没有多少优势。

您可以做更多的事情来改善QuickSort的实现，但是我看不到任何其他真正的错误。