Java 气泡排序实现对数组进行排序。效率如何？

当我翻阅一本书时，我用一种算法对一个数组进行排序。我编写的算法有一个名称（气泡排序）。我想知道我粗略编写的程序是否完美地实现了冒泡排序算法，或者是否有更有效的方法实现同样的功能

import java.util.Arrays;
public class Tool {
    public static void main(String[] args){

        int[] n = {4,8,12,87,32,98,12,45,94,42,938,84,63,67,86,37};
        int inter = 0;

        int arrayLength = n.length;

        int pass = arrayLength-1;
        for(int y = 0; y < arrayLength - 1; y++) {
            for(int x = 0; x < pass; x++) {
                if(n[x] < n[x + 1]) {
                    inter = n[x];
                    n[x] = n[x + 1];
                    n[x + 1] = inter;
                    num++;
                }

            }
            pass--;
        }
        // To print the resulting array
        System.out.println(Arrays.toString(n));
    }
}

导入java.util.array；
公共类工具{
公共静态void main（字符串[]args）{
int[]n={4,8,12,87,32,98,12,45,94,42938,84,63,67,86,37}；
int-inter=0；
int arrayLength=n.长度；
int pass=阵列长度-1；
对于（int y=0；y

请参阅

Bubblesort，也称为sinkingsort，是一种简单的排序算法，通过重复单步遍历要排序的列表，比较每对相邻项，并在它们顺序错误时交换它们。重复传递列表，直到不需要交换，这表示列表已排序。该算法的名称来源于较小元素“冒泡”到列表顶部的方式。因为它只使用比较来对元素进行操作，所以它是一种比较排序。虽然算法简单，但对大列表排序效率不高；其他算法更好

冒泡排序的最坏情况和平均复杂度均为o（n2），其中n 是正在排序的项目数。存在许多排序 具有更好的最坏情况或平均复杂度的算法 O（n对数n）的对数。甚至其他的o（n2）排序算法，如插入 排序，往往比冒泡排序具有更好的性能。所以,， 当n较大时，冒泡排序不是一种实用的排序算法

泡泡排序法与其他大多数排序法相比唯一的显著优势是 实现，即使是快速排序，但不是插入排序，是 有效地将检测列表已排序的能力内置到 算法。对已排序的列表执行气泡排序 （最佳情况）为O（n）。相比之下，大多数其他算法，甚至那些 使用更好的平均案例复杂性，执行其整个排序 过程集中，因此更为复杂。然而，不仅如此 插入排序也有这种机制，但它在 基本上已排序的列表（有少量的 倒置）

气泡排序中元素的位置将在很大程度上决定其性能。列表开头的大型元素不会造成问题，因为它们可以快速交换。然而，接近结尾的小元素移动到开头的速度非常缓慢

该行话文件著名地将bogosort称为“典型的异常糟糕的算法”，也将bubble排序称为“通用的糟糕算法”。唐纳德·克努特（Donald Knuth）在其著名的著作《计算机编程艺术》（The Art of Computer Programming）中总结道：“除了一个吸引人的名字外，泡沫排序似乎没有什么值得推荐的

冒泡排序与现代CPU硬件的交互也很差。它需要的写操作数至少是插入排序的两倍，缓存未命中的两倍

在Java中显示冒泡排序大约比慢5倍，慢40%

---

算法基本上是O（n^2）（注意：这是排序最复杂的算法之一）

---

有一个小的优化，如果一个贯穿的内部循环不产生任何交换，那么您可以打破外部循环，因为这表明数组已完全排序。对于已经排序的数据，这会给您一个O（n）的最佳情况（尽管我不认为最佳情况称为O）.

一个寻找算法实现的好网站是。你可以找到关于冒泡排序的文章

看起来您的代码缺少检查交换是否确实必要的优化（正如Loki Astari所指出的）

此代码取自上面的URL，它实现了此优化：

public void bubbleSort（int[]arr）{
布尔交换=真；
int j=0；
int tmp；
while（交换）{
交换=假；
j++；
对于（int i=0；iarr[i+1]）{
tmp=arr[i]；
arr[i]=arr[i+1]；
arr[i+1]=tmp；
交换=真；
}
}
}
}

你可以从那个页面上读到更多关于它的信息，如果你是一个视觉学习者（像我一样），它也有一些有用的图表

---

Cheers

严格来说，这不是冒泡排序算法的实现。它是冒泡排序的改进版本的实现，但是，它没有正确实现

该实现使用了这样一个事实，即第一次传递后最后一个项位于正确的位置，因此下一次传递可以对一个较少的项进行排序。原始的冒泡排序算法只是一直循环遍历所有项

缺少的是，当不再进行交换时，该算法不会进行检查，相反，它会一直循环，直到达到最坏情况下所需的最大迭代次数。这意味着它通常会在所有内容都已排序后长时间保持循环。有一个变量

num

这似乎是为了实现这一点，但有点错误，因为该变量没有在任何地方声明

您应该在内部循环之前将

num

初始化为零，并在循环通过项目后循环直到它仍然为零：

import java.util.Arrays;
public class Tool {

  public static void main(String[] args){

    int[] n={4,8,12,87,32,98,12,45,94,42,938,84,63,67,86,37};

    int pass = n.length - 1;
    int num;
    do {
      num = 0;

      for(int x = 0; x < pass; x++){
        if(n[x] < n[x + 1]){
          int temp = n[x];
          n[x] = n[x + 1];
          n[x + 1] = temp
          num++;
        }

      }
      pass--;

    } while (num != 0);
    // To print the resulting array
    System.out.println(Arrays.toString(n));

  }
}

im