Java气泡排序行为奇怪

我这里有一个使用Java进行冒泡排序的函数，这段代码可以对数组进行排序。然而，问题是我不知道它是如何排序的，因为它看起来不像标准的冒泡排序

public static void swap (int [ ] data, int index1, int index2)
// POST: elements at indexes are exchanged
{   int temp = data[index1];                                // temporary to hold first value
    data[index1] = data[index2];
    data[index2] = temp;
}

public static void bubbleSort (int [ ] data)
// POST: elements in data array are sorted in ascending order
{   for (int ct1=0; ct1<data.length-1; ct1++)           // outer loop moves one element into place
    {   for (int ct2=0; ct2<data.length-1-ct1; ct2++)
            if (data[ct2] > data[ct2+1])                    // swap if element on left bigger than right
                swap (data, ct2,ct2+1);
        for (int i = 0; i < data.length; i++) System.out.print(data[i] + " ");
        System.out.println();
    }
}

有人能解释一下吗

---

它似乎在比较任意值，并且没有像它应该检查的那样检查40和90。

在bubbleSort方法中，您正在从0到数组长度-1的范围内启动一个数组。相反，只需使其简单，并按如下方式反向运行：

public static void bubbleSort(int [] data) {
    int k;
    for (int m = data.length; m >= 0; m--) {
        for (int i = 0; i < data.length - 1; i++) {
            k = i + 1;
            if (array[i] > array[k]) {
                swapNumbers(i, k, array);
            }
        }
      // Time to test this new array here:
    for (int i = 0; i < data.length; i++) {
        System.out.print(data[i] + ", ");
    }
        System.out.println("\n");           
    }
}

publicstaticvoidbubblesort（int[]数据）{
int k；
对于（int m=data.length；m>=0；m--）{
对于（int i=0；i数组[k]）{
SwapNumber（i，k，数组）；
}
}
//在此处测试此新阵列的时间：
对于（int i=0；i

---

检查您的解决方案是否正确打印，并让我知道它将被交换，直到与ct2的单循环结束。 内循环，将运行4次

它就像一块石头掉进水里

---

英语很差，对不起~

你的冒泡排序也在按你所期望的方式运行。 它按相反顺序从低到高排序（即最后一列先设置）

我认为您遇到的问题是输出采样频率 和你脑子里想的不匹配

如果你稍微修改一下代码

public static void swap (int [ ] data, int index1, int index2){
    int temp = data[index1];
    data[index1] = data[index2];
    data[index2] = temp;
}

public static void bubbleSort (int [ ] data) {
    for (int ct1=0; ct1<data.length-1; ct1++) {
        for (int ct2=0; ct2<data.length-1-ct1; ct2++) {
            if (data[ct2] > data[ct2 + 1]) {
                swap(data, ct2, ct2 + 1);
            // non functional change to move sampling point
                for (int i = 0; i < data.length; i++) {
                     System.out.print(data[i] + " ");
                }
                System.out.println();
            }
        }
    }
}

public static void main(String[] args) {
    bubbleSort(new int[]{40,90,10,60,20});
}

---

这正是我认为您希望看到的。

它看起来并不是随意比较事物。它所做的正是代码让它做的。从字面上说，它是将较大的值“冒泡”到数组的末尾。在您的第一个内部循环中，设置一个

System.out.println

——这可能有助于您澄清它。该行为符合您的理解。您创建的输出是在处理每一行之后，而不是在每次交换之后。你应该多用牙套，这正是我要找的凯文。如果你贴出答案，我会接受。

public static void swap (int [ ] data, int index1, int index2){
    int temp = data[index1];
    data[index1] = data[index2];
    data[index2] = temp;
}

public static void bubbleSort (int [ ] data) {
    for (int ct1=0; ct1<data.length-1; ct1++) {
        for (int ct2=0; ct2<data.length-1-ct1; ct2++) {
            if (data[ct2] > data[ct2 + 1]) {
                swap(data, ct2, ct2 + 1);
            // non functional change to move sampling point
                for (int i = 0; i < data.length; i++) {
                     System.out.print(data[i] + " ");
                }
                System.out.println();
            }
        }
    }
}

public static void main(String[] args) {
    bubbleSort(new int[]{40,90,10,60,20});
}

40 10 90 60 20 
40 10 60 90 20 
40 10 60 20 90 
10 40 60 20 90 
10 40 20 60 90 
10 20 40 60 90