Java 这两种冒泡排序实现之间的差异

我有两个冒泡排序的实现，但其中一个运行良好，另一个无法解释这两个的区别

第一个很好用

private static int[] sortBuble(int[] a) {
        boolean swapped = true;
        for (int i = 0; i < a.length && swapped; i++) {
            swapped = false;
            System.out.println("number of iteration" + i);

            for (int j = 1; j < a.length; j++) {

                if (a[j - 1] > a[j]) {
                    int temp = a[j - 1];
                    a[j - 1] = a[j];
                    a[j] = temp;
                    swapped = true;
                }
            }
        }

        return a;
    }

私有静态int[]sortBuble（int[]a）{
布尔交换=真；
对于（int i=0；ia[j]）{
内部温度=a[j-1]；
a[j-1]=a[j]；
a[j]=温度；
交换=真；
}
}
}
返回a；
}

第二，这不起作用，但它们看起来差不多

private static int[] sortBuble1(int[] a) {
        boolean swapped = true;
        for (int i = 0; i < a.length && swapped; i++) {
            swapped = false;
            System.out.println("number of iteration" + i);

            for (int j = i + 1; j < a.length; j++) {

                if (a[i] > a[j]) {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                    swapped = true;
                }
            }
        }

        return a;
    }

private static int[]sortBuble1（int[]a）{
布尔交换=真；
对于（int i=0；ia[j]）{
int temp=a[i]；
a[i]=a[j]；
a[j]=温度；
交换=真；
}
}
}
返回a；
}

它们不一样。在第二个示例中，对于内部for循环的每次迭代，您都保持i常量，并使用

a[i]

进行比较，这是不正确的。正如我在另一个答案中所说，第一个答案也是低效的。以下是第一个版本的优化版本：

private static int[] bubblesort(int[] nums)
{
    boolean done = false;

    for (int i = 0;  i < nums.length && !done; i++)
    {
        done = true;

        for (int j = nums.length-1; j > i; j--)
        {
            if (nums[j] < nums[j-1])
            {
                int temp = nums[j];
                nums[j] = nums[j-1];
                nums[j-1] = temp;
                done = false;
            }
        }
    }

    return nums;
}

私有静态int[]bubblesort（int[]nums）
{
布尔完成=假；
对于（int i=0；ii；j--）
{
if（nums[j]

---

在第i次迭代结束时，我们知道第一个i元素已排序，因此我们不再需要查看它们。我们需要布尔值来确定是否需要继续。如果没有互换，那么我们就完了。我们可以删除布尔值，它仍然可以工作，但效率会降低

它们不一样。在第二个示例中，对于内部for循环的每次迭代，您都保持i常量，并使用

a[i]

进行比较，这是不正确的。正如我在另一个答案中所说，第一个答案也是低效的。以下是第一个版本的优化版本：

private static int[] bubblesort(int[] nums)
{
    boolean done = false;

    for (int i = 0;  i < nums.length && !done; i++)
    {
        done = true;

        for (int j = nums.length-1; j > i; j--)
        {
            if (nums[j] < nums[j-1])
            {
                int temp = nums[j];
                nums[j] = nums[j-1];
                nums[j-1] = temp;
                done = false;
            }
        }
    }

    return nums;
}

私有静态int[]bubblesort（int[]nums）
{
布尔完成=假；
对于（int i=0；ii；j--）
{
if（nums[j]

---

在第i次迭代结束时，我们知道第一个i元素已排序，因此我们不再需要查看它们。我们需要布尔值来确定是否需要继续。如果没有互换，那么我们就完了。我们可以删除布尔值，它仍然可以工作，但效率会降低

不同之处在于用于数组的索引

在第一种情况下，带有

j

的

for

内部循环独立于

i

。此外，在交换时使用

j

的相邻值，以便始终交换数组中的相邻值

---

在第二种情况下，内部

for

循环从

i+1

开始

j

。您同时使用

i

和

j

对数组进行索引。因此，您实际上不是在比较相邻的元素，而是比较可能相距很远的元素（例如，当

i=1

和

j=4

时）。这不是冒泡排序，而且该算法不会以这种方式工作。

区别在于用于数组的索引

在第一种情况下，带有

j

的

for

内部循环独立于

i

。此外，在交换时使用

j

的相邻值，以便始终交换数组中的相邻值

---

在第二种情况下，内部

for

循环从

i+1

开始

j

。您同时使用

i

和

j

对数组进行索引。因此，您实际上不是在比较相邻的元素，而是比较可能相距很远的元素（例如，当

i=1

和

j=4

时）。这不是冒泡排序，而且该算法不会以这种方式工作。

您如何知道前i个元素已排序？你所做的只是颠倒循环的顺序。e、 g.它会在这个[1 2 3 4 5 6 7 8 9 0]上工作吗？0将如何到达第一个元素？@过于乐观如果我们从列表的末尾开始，每次交换

nums[j]>nums[j-1]

，那么最小的元素必须在迭代结束时的开头，这样我们就可以在下一次迭代中跳过该元素。这是对上述代码的概括。对不起，意思是

nums[j]

。您如何知道前i个元素是如何排序的？你所做的只是颠倒循环的顺序。e、 g.它会在这个[1 2 3 4 5 6 7 8 9 0]上工作吗？0将如何到达第一个元素？@过于乐观如果我们从列表的末尾开始，每次交换

nums[j]>nums[j-1]

，那么最小的元素必须在迭代结束时的开头，这样我们就可以在下一次迭代中跳过该元素。这是对上述代码的概括。对不起，意思是

nums[j]

。