【排序算法（二）】冒泡排序及其改进

基本思想

对当前还未排好序的范围内的全部数，自上而下对相邻的俩个数依次进行比较和调整，让较大的数下沉，较小的数往上冒。即：每当俩相邻的数比较后发现他们的排序与排序的要求相反时，就将他们交换。每次遍历都可确定一个最大值放到待排数组的末尾，下次遍历，对该最大值以及它之后的元素不再排序（已经排好）。

由于冒泡排序算法交换和比较的操作次数都与N2成正比，由于在大O表示法中，常数忽略不计，冒泡排序的时间复杂度为O(N2)。O(N2)的时间复杂度是一个比较糟糕的结果，尤其在数据量很大的情况下。所以冒泡排序通常不会用于实际应用。
冒泡排序算法相比于其他排序算法的唯一显著优势是可以检测输入序列是否已经是排序的。

Java版本实现

public class BubbleSort1<T extends Comparable<T>> extends Sort<T> {
    @Override
    public void sort(T[] nums) {
        int n = nums.length;
        boolean isSorted = false;

        for (int i = 0; i < n - 1 && !isSorted; i++) {
            isSorted = true;
            for (int j = 1; j < n - i; j++) {
                if (less(nums[j], nums[j - 1])) {
                    swap(nums, j, j - 1);
                    isSorted = false;
                }
            }
        }
    }
 }

传统的冒泡算法每次排序只确定了最大值，我们可以在每次循环之中进行正反两次冒泡，分别找到最大值和最小值，如此可使排序的轮数减少一半。

改进代码如下：

//优化版本
public class BubbleSort2<T extends Comparable<T>> extends Sort<T> {
    @Override
    public void sort(T[] nums) {
        int n = nums.length;
        boolean isSorted = false;

        int low = 0, high = n - 1;
        while (low < high && !isSorted) {
            isSorted = true;
            // 逆向冒泡，大的往下沉
            for (int j = low; j < high; j++) {
                if (less(nums[j + 1], nums[j])) {
                    swap(nums, j, j + 1);
                    isSorted = false;
                }
            }
            high--;
            // 正向冒泡，小的往上浮
            for (int j = high; j > low; j--) {
                if (less(nums[j], nums[j - 1])) {
                    swap(nums, j, j - 1);
                    isSorted = false;
                }
            }
            low++;
        }
    }
 }

继承的抽象类 Sort

package com.wuyi.notecode.sort;

public abstract class Sort<T extends Comparable<T>>{

    public abstract void sort(T[] nums);

    protected boolean less(T v, T w){
        return v.compareTo(w) < 0;
    }

    protected void swap(T[] nums, int i, int j){
        if (i == j)
            return;

        T temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

    protected void display(T[] nums){
        for (T a : nums){
            System.out.print(a + " ");
        }
        System.out.println();
    }
}

测试代码

 public static void main(String[] args) {
        BubbleSort2<Integer> sortInt = new BubbleSort2<>();
        Integer a[] = {4, 9, 1, 2, 5, 8, 7, 6};
        sortInt.sort(a);
        System.out.println("最终结果：");
        sortInt.display(a);

        BubbleSort2<Double> sortDouble = new BubbleSort2<>();
        Double b[] = {2.2, 58.3, 6.0, 56.1, 5.1, 93.63};
        sortDouble.sort(b);
        System.out.println("最终结果：");
        sortDouble.display(b);

        BubbleSort2<String> sortStr = new BubbleSort2<>();
        String s[] = {"d", "f", "D", "r", "U"};
        sortStr.sort(s);
        System.out.println("最终结果：");
        sortStr.display(s);
    }