java实现八大排序算法之冒泡排序

java实现八大排序算法之冒泡排序

排序的分类：

1：基于比较次数（时间复杂度）
在这种方法中，排序算法根据比较的次数进行分类。对于基于这种比较的排序算法来说，最好情况下的时间复杂度是O(nlogn)，最坏情况下的时间复杂度为O(n^2)。

2：基于存储器使用量（空间复杂度）
一些排序算法“就地”进行排序，它们需要O(1)或O(logn)的存储空间为排序的数据创建临时辅助存储位置。

3：基于稳定性
什么叫做稳定性这个需要大家熟知。
array[i]和array[j]是相同的关键字记录，在原始文件中记录array[i]位于记录array[j]之前，排序后得到的有序列表中记录array[i]仍位于array[j]之前，则说明排序算法是稳定的。也就是说，即使在排序完之后，关键字相同的元素仍保持他们之间的相对位置。

冒泡排序：

冒泡排序是最简单的一种排序算法。它从输入数组的第一个元素开始迭代到最后一个元素，比较相邻的每对元素并在需要时进行交换。冒泡排序持续这一迭代过程，直到不再需要交换元素为止。该元素因较小的元素会冒到列表的顶部而获得其名称。
冒泡排序与其他排序算法相比，唯一显著的优点是他可以检测输入列表是否是有序序列。

实现：

public static void bubbleSort(int [] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }

进一步改进算法，每迭代一次后就会有一个元素到相应位置，无需再次与这个元素比较。

   public static void bubbleSort1(int [] array) {
        //迭代n-1次
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }

再次进一步改进算法，设置一个标签。没有发生交换就说明已经是有序序列了。如果序列有序，那么我们可以利用这个标签跳过剩下的排序过程了。

  public static void bubbleSort2(int [] array) {
        int flag = 1;
        //迭代n-1次
        for (int i = 0; i < array.length - 1 && flag == 1; i++) {
            flag = 0;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = 1;
                }
            }
        }
    }

性能：

最坏情况下的时间复杂度：O(n^2)
最好情况下的时间复杂度：O(n)
平均情况下的时间复杂度：O(n^2)
最坏情况下的空间复杂度：O(1)

稳定性：

冒泡排序是稳定的。