如何调试我的冒泡排序代码？ [关闭]

Question

我在大学得到了这个bubblesort，并且正在尝试运行它！它应该按大小顺序对数字进行排序，从小到大。任何帮助，将不胜感激。 （它来自 YouTube 上的 Derek Banas）。你知道为什么它不起作用吗？

public class ListForSorting {

    int arraySize = 10;
    int[] myArray = { 10, 12, 3, 4, 50, 60, 7, 81, 9, 100 };

    public void printArray() {

        System.out.println("----------");
        for (int i = 0; i < arraySize; i++) {

            System.out.print("| " + i + " | ");
            System.out.println(myArray[i] + " |");

            System.out.println("----------");

        }

    }

    public static void main(String[] args) {
        ListForSorting list = new ListForSorting();

        list.printArray();

        list.bubbleSort();
        list.printArray();
    }

    public void bubbleSort() {

        for (int i = arraySize - 1; i > 1; i--) {
            for (int j = 0; j < i; j++) {
                if (myArray[j] < myArray[j + 1])
                    swap(j, j + 1);

            }
        }

    }

    public void swap(int indexOne, int indexTwo) {
        int temp = myArray[indexOne];
        myArray[indexOne] = myArray[indexTwo];
        temp = myArray[indexTwo];
    }
}

输出：

----------
| 0 | 10 |
----------
| 1 | 12 |
----------
| 2 | 3 |
----------
| 3 | 4 |
----------
| 4 | 50 |
----------
| 5 | 60 |
----------
| 6 | 7 |
----------
| 7 | 81 |
----------
| 8 | 9 |
----------
| 9 | 100 |
----------
----------
| 0 | 81 |
----------
| 1 | 100 |
----------
| 2 | 100 |
----------
| 3 | 100 |
----------
| 4 | 100 |
----------
| 5 | 100 |
----------
| 6 | 100 |
----------
| 7 | 100 |
----------
| 8 | 100 |
----------
| 9 | 100 |

谢谢！

Answer 1

您的swap 函数有误。应该是这样的：

public void swap(int indexOne, int indexTwo) {
    int temp = myArray[indexOne];
    myArray[indexOne] = myArray[indexTwo];
    myArray[indexTwo] = temp;
}

另外，bubblesort 函数也有错误。计数器 i 应该下降到 1 而不是 2，否则您的第一个元素将不会按应有的方式排序：

public void bubbleSort() {

        for (int i = arraySize - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (myArray[j] < myArray[j + 1])
                    swap(j, j + 1);

            }
        }

    }

现在输出：

----------
| 0 | 10 |
----------
| 1 | 12 |
----------
| 2 | 3 |
----------
| 3 | 4 |
----------
| 4 | 50 |
----------
| 5 | 60 |
----------
| 6 | 7 |
----------
| 7 | 81 |
----------
| 8 | 9 |
----------
| 9 | 100 |
----------
----------
| 0 | 100 |
----------
| 1 | 81 |
----------
| 2 | 60 |
----------
| 3 | 50 |
----------
| 4 | 12 |
----------
| 5 | 10 |
----------
| 6 | 9 |
----------
| 7 | 7 |
----------
| 8 | 4 |
----------
| 9 | 3 |
----------

如果你想从最小到最大，只需在bubblesort函数中更改if条件：

public void bubbleSort() {

        for (int i = arraySize - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (myArray[j] > myArray[j + 1])
                    swap(j, j + 1);

            }
        }

    }

现在，输出将是：

----------
| 0 | 10 |
----------
| 1 | 12 |
----------
| 2 | 3 |
----------
| 3 | 4 |
----------
| 4 | 50 |
----------
| 5 | 60 |
----------
| 6 | 7 |
----------
| 7 | 81 |
----------
| 8 | 9 |
----------
| 9 | 100 |
----------
----------
| 0 | 3 |
----------
| 1 | 4 |
----------
| 2 | 7 |
----------
| 3 | 9 |
----------
| 4 | 10 |
----------
| 5 | 12 |
----------
| 6 | 50 |
----------
| 7 | 60 |
----------
| 8 | 81 |
----------
| 9 | 100 |
----------

编辑：性能

如果内部循环至少进行了一次交换，您可以通过“检查”来加快速度。如果没有，则意味着您可以在外循环完成后就存在，并为其余的外循环迭代节省时间。

Answer 2

您的代码中遇到的问题很少，最有问题的是：

1. 交换错误（最后一行应该颠倒）

2. 你正在循环整个事情 N-1 次

   只有在对数组进行排序之前，这才是不必要的循环。所以直到在内循环中没有发生交换。

我这样编码升序冒泡排序（在 C++ 中）：

void sort_asc(int *a,int n)
    {
    int i,e;
    for (e=1;e;n--)                 // loop until no swap occurs
     for (e=0,i=1;i<n;i++)          // process array
      if (a[i-1]>a[i])              // if swap needed
       {
       e=a[i-1];                    // swap
       a[i-1]=a[i];
       a[i]=e;
       e=1;                         // allow to process array again
       }
    }

用法：

int a[]={ 9,8,7,6,5,4,3,2,1,0 };    // worse case scenario
sort_asc(a,sizeof(a)/sizeof(a[0]));

降序只是将条件更改为：

      if (a[i-1]<a[i])              // if swap needed

顺便说一句，这里对循环 100 次 32 位 int a[1024] 数组进行排序的一些测量：

                         Time        Space

[   1.428 ms] Worse case O(n)
[ 312.744 ms] Bubble asc O(n^2)      O(1     ) OK
[ 306.084 ms] Bubble dsc O(n^2)      O(1     ) OK
[   9.883 ms] Quick  asc O(n.log(n)) O(log(n)) OK
[  10.620 ms] Quick  dsc O(n.log(n)) O(log(n)) OK

[   1.816 ms] Random     O(n)
[ 374.343 ms] Bubble asc O(n^2)      O(1     ) OK
[ 361.219 ms] Bubble dsc O(n^2)      O(1     ) OK
[  14.402 ms] Quick  asc O(n.log(n)) O(log(n)) OK
[  14.519 ms] Quick  dsc O(n.log(n)) O(log(n)) OK

asc 和 desc 排序具有相同的速度，只是由于 CACHE 造成了轻微的测量差异，因为它们都使用相同的内存空间，因此在测试中首先调用哪个会更慢，而第二个会受益从内存已经映射到 CACHE 的事实来看（如果不是太大的粗略）。顺便说一句，这段代码可以进一步优化一点......