冒泡哪一个？

Question

首先：

for(int i=0;i<n-1;i++)
  for(int j=n-1; j>i;j--)
    if(a[j] < a[j-1])
        swap(a[j], a[j-1]);

或者第二个：

for(int i=0; i<n-1; i++)
  for(int j=i+1; j<n; j++)
    if(a[j] < a[i])
        swap(a[j],a[i]);

或第三版：

int temp, i, j = 0;
    boolean swaped = true;

    while (swaped) {
        swaped = false;
        j++;
        for(i = 0; i < arr.length - j; i++){
            if(arr[i] > arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
                swaped = true;
            }
        }
    }

有人说第一个，有人说第二个。 那么哪一个是对的？ 有人说第二种是交换排序。 很多书说冒泡排序是第三个版本，但很多人称第一个版本是冒泡排序。 任何意见？

Answer 1

第一个版本是冒泡排序，因为它正在比较每对相邻的项目。

第二个版本是选择排序，因为在外循环的每次迭代之后， a[i]最终成为数组未排序右侧部分中的最小项。

Answer 2

我在IntelliJ中使用Java在实际数组上测试了两个代码片段。 两个版本都按升序排序生成数组。

这是我使用的数组：

int[] a = {1, 9, 3, 5, 4, 2, 8, 6, 7};

以下是两个版本的输出：

版本1

[1, 2, 3, 4, 5, 6, 7, 8, 9]

版本2

[1, 2, 3, 4, 5, 6, 7, 8, 9]

第一个版本看起来像标准的冒泡排序，而第二个版本看起来是另一个版本。

Answer 3

1.第一个：

for(int i=0;i<n-1;i++)
  for(int j=n-1; j>i;j--)
    if(a[j] < a[j-1])
        swap(a[j], a[j-1]);

这是冒泡排序

第二个：

for(int i=0; i<n-1; i++)
  for(int j=i+1; j<n; j++)
    if(a[j] < a[i])
        swap(a[j],a[i]);

这是选择排序

即使乍一看它会给人一种印象，即它是泡沫排序的反向实现，但事实并非如此。 它是已经被其他用户指出的选择排序

3.第三版：

int temp, i, j = 0;
    boolean swaped = true;

    while (swaped) {
        swaped = false;
        j++;
        for(i = 0; i < arr.length - j; i++){
            if(arr[i] > arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
                swaped = true;
            }
        }
    }

事实上， 增强的冒泡排序这将改善最佳情况