我已经用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
答案 0 :(得分：3)
至于如何计算操作，您可以考虑添加一个间接层。例如，使用诸如此类的类来执行和计算操作：
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 - 如果您执行和计算自交换，则为其中一个）。
然后就是你的快速排序。显然它不是很快 - 它有一些非常严重的错误。更多的仪器告诉我，它正在下降到远太大的递归深度（平均约为400，而即使在最坏的情况下也不应超过 n ）。问题在于您的随机数据库选择。您不是从要排序的子数组中选择一个数据透视，而是从整个数组中选择它。要解决此问题，请替换
int randomIndex = new Random().nextInt(array.length);
与
int randomIndex = left + new Random().nextInt(right + 1 - left);
这应该会给你更多有利的比较和掉期计数，但你不会真正注意到Quick sort提供了多少优势，直到你开始排序更大的数组。
您可以采取更多措施来改进QuickSort实施，但我没有看到任何其他真正的错误。