Question

我使用算法对数组进行了排序，当我读书时。我写的算法名称为（BUBBLE SORT）。我想知道我粗略编写的程序是否完美地实现了冒泡排序算法，还是有更有效的方法来做同样的事情？

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));
    }
}

Answer 1

寻找算法实施的好网站是http://www.algolist.com。您可以找到关于冒泡排序here的文章。

看起来你的代码缺乏优化，检查交换是否真的有必要（正如Loki Astari所说）。

此代码取自上述URL，该URL实现了此优化：

public void bubbleSort(int[] arr){
    boolean swapped = true;
    int j = 0;
    int tmp;
    while(swapped){
        swapped = false;
        j++;
        for(int i = 0; i < arr.length - j; i++){
            if(arr[i] > arr[i + 1]){
                tmp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = tmp;
                swapped = true;
            }
        }
    }
}

你可以从那个页面上阅读更多关于它的信息，如果你更像是一个视觉学习者（比如我自己），它也会提供有用的图表。

干杯

Answer 2

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

实现使用的事实是，在第一次传递之后，已知最后一个项目位于正确的位置，因此下一个传递可以对一个项目进行排序。原始的冒泡排序算法只是循环遍历所有项目。

缺少的是该算法不检查何时没有进行交换，而是保持循环，直到达到最大可能情况下所需的最大迭代次数。这意味着它通常会在所有内容已经排序后保持循环。有一个变量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));

  }
}

Answer 3

请参阅。

冒泡排序，也称为沉没排序，是一种简单的排序算法，通过重复单步执行排序列表，比较每对相邻项目和如果它们的顺序错误则交换它们。重复传递列表，直到不需要交换，这表明列表已排序。该算法的名称来自较小元素“冒泡”到列表顶部的方式。因为它只使用比较来操作元素，所以它是一种比较排序。虽然算法很简单，但对大型列表进行排序效率不高;其他算法更好。 Wikipedia

冒泡排序具有最坏情况和平均复杂度О（n2），其中n   是要排序的项目数。存在许多排序   具有明显更好的最坏情况或平均复杂度的算法   O（n log n）。甚至其他О（n2）排序算法，例如插入   排序，往往比冒泡排序具有更好的性能。因此，   当n很大时，冒泡排序不是一种实用的排序算法。

冒泡排序相对于大多数其他的唯一显着优势   实现，甚至快速排序，但不是插入排序，是   能够有效地检测列表是否已排序   算法。对已经排序的列表进行冒泡排序的性能   （最好的情况）是O（n）。相比之下，大多数其他算法，甚至那些   具有更好的平均情况复杂度，执行整个排序   集合上的过程因此更复杂。但是，不仅如此   插入排序也有这种机制，但它也表现更好   一个基本排序的列表（具有少量的   倒位）。

冒泡排序中元素的位置将在决定其性能方面发挥重要作用。列表开头的大元素不会造成问题，因为它们可以快速交换。然而，走向终点的小元素极其缓慢地开始。

Jargon文件，着名的称为bogosort“典型的反常算法”，也称泡沫排序为“通用的坏算法”。2 Donald Knuth在他的着名着作“计算机程序设计的艺术”中得出结论， “除了一个吸引人的名字之外，泡泡似乎没有什么值得推荐的。

冒泡排序也与现代CPU硬件交互不良。它需要至少两倍于插入排序的写入次数，是缓存未命中次数的两倍。
     Java中的
显示冒泡排序大约比insertion sort慢5倍，比selection sort 慢40％。

Answer 4

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

如果通过内部循环运行不产生任何交换，那么有一个小优化，那么你可以突破外部循环，因为这表明数组已经完全排序。这为已排序的数据提供了O（n）的最佳情况（尽管我认为它不是最佳情况下的O）。

冒泡排序实现排序数组。效率如何？

4 个答案: