算法笔记——冒泡排序(Java实现)

冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。

1. 算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2. 动图演示

3.源代码

import java.util.Arrays;

public class BubbleSort {

    // 我们的算法类不允许产生任何实例
    private BubbleSort(){}

    public static void sort(Comparable[] arr){

        int n = arr.length;
        boolean swapped = false;
        //用来记录是否发生了交换，如果上一趟没有发生交换，就说明数组已经排序完成
        do{
            swapped = false;
            for( int i = 1 ; i < n ; i ++ )
                if( arr[i-1].compareTo(arr[i]) > 0 ){
                    swap( arr , i-1 , i );
                    swapped = true;
                }

            // 优化, 每一趟Bubble Sort都将最大的元素放在了最后的位置
            // 所以下一次排序, 最后的元素可以不再考虑
            n --;
        }while(swapped);
    }

    private static void swap(Object[] arr, int i, int j) {
        Object t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

4.优化思路

我们一趟完成之后最后一个元素已经正确的"上浮"到了顶部，但是我们要想到，每一趟排序之后可能不止最后一个元素是正确的，在处理近乎有序数组时，可能一趟排序可以使很多元素找到正确位置，所以我们可以设置一个标志位，来记录最后一次元素交换的位置，下一趟排序就不需要考虑这之后的元素了，下面我们就分别以普通的乱序数组和近乎有序的数组来分别测试一下效率的提升。

先是优化后的源代码

import java.util.Arrays;

public class BubbleSort2 {

    // 我们的算法类不允许产生任何实例
    private BubbleSort2(){}

    public static void sort(Comparable[] arr){

        int n = arr.length;
        int newn; // 使用newn进行优化

        do{
            newn = 0;
            for( int i = 1 ; i < n ; i ++ )
                if( arr[i-1].compareTo(arr[i]) > 0 ){
                    swap( arr , i-1 , i );

                    // 记录最后一次的交换位置,在此之后的元素在下一轮扫描中均不考虑
                    newn = i;
                }
            n = newn;
        }while(newn > 0);
    }

    private static void swap(Object[] arr, int i, int j) {
        Object t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

测试代码

//测试近乎有序的数组
public static void main(String[] args){
        Integer[] arr1 = SortTestHelper.generateNearlyOrderedArray(200000,10);
        Integer[] arr2 = Arrays.copyOf(arr1,arr1.length);
        SortTestHelper.testSort("com.company.BubbleSort",arr1);
        System.out.println();
        SortTestHelper.testSort("com.company.BubbleSort2",arr2);
        System.out.println();

    }

测试结果

可以看出提升比较明显

//测试正常的乱序数组
public static void main(String[] args){
        Integer[] arr1 = SortTestHelper.generateRandomArray(50000,1,100000);
        Integer[] arr2 = Arrays.copyOf(arr1,arr1.length);
        SortTestHelper.testSort("com.company.BubbleSort",arr1);
        System.out.println();
        SortTestHelper.testSort("com.company.BubbleSort2",arr2);
        System.out.println();

    }

测试结果

可以看出，在这方面差距不是很明显，但是bubblesort2提升了面对特殊情况时算法的效率，所以我一般会选择第二种。当然，冒泡算法一般是锻炼思路的，实践意义不是很大。