深入探究Java数据结构与算法系列（三）——冒泡排序（基础算法）

    引言：     

       在切入到算法这个领域之前，像很多人一样都会去了解这个算法的原理以及它的实现代码。也正是说明了它是总多算法当中的基础中基础，也是带领我们深入到各个算法当中不可或缺的一个步骤，如果有过一点算法基础的人或缺会有个印象，冒泡排序用到了两个for循环，那么一般我们都认为它的时间复杂度为O(N²),,那么今天我们来探究一下冒泡排序算法的实现。

    基础原理：

         这个名词的由来很好理解，一般河水中的冒泡，水底刚冒出来的时候是比较小的，随着慢慢向水面浮起会逐渐增大，这物理规律我不作过多解释，大家只需要了解即可。

　　冒泡算法的运作规律如下：

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

　　②、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数（也就是第一波冒泡完成）。

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

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

下面是代码的实现：

package sort;

/**
 * @author hegx
 */
public class BubbleSort {
    /**
     * 冒泡排序
     * @param array
     * @return array
     */
    private static int[] bubbleSort(int[] array) {
        int temp;
        display(array);
        System.out.println("数组内容开始排序....");
        for (int i = 1; i < array.length; i++) {
            //标识排序成功，true排好序，否则false
            boolean flag = true;
            for (int j = 0; j < array.length-1; j++) {
                if (array[j] > array[j+1]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = false;
                }
            }
            if (flag==true){
                break;
            }
            System.out.print("第"+i+"论排序结果：");
            display(array);
        }
        System.out.println("冒泡法排序结束");
        return array;
    }

    /**
     * 遍历打印数组
     * @param array
     */
    private static void display(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"\t");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[]  array = {3,9,5,1,8,2,6,7,4};
        bubbleSort(array);
        display(array);
    }

}

程序运行结果：

 

本来应该是 8 轮排序的，这里我们只进行了 5轮排序，因为第 5 轮排序之后已经是有序数组了。

冒泡排序解释：

　　冒泡排序是由两个for循环构成，第一个for循环的变量 i 表示总共需要多少轮比较，第二个for循环的变量 j 表示每轮参与比较的元素下标【0,1，......，length-i】，因为每轮比较都会出现一个最大值放在最右边，所以每轮比较后的元素个数都会少一个，这也是为什么 j 的范围是逐渐减小的。相信大家理解之后快速写出一个冒泡排序并不难。

　　冒泡排序性能分析：

　　假设参与比较的数组元素个数为 N，则第一轮排序有 N-1 次比较，第二轮有 N-2 次，如此类推，这种序列的求和公式为：

　　（N-1）+（N-2）+...+1 = N*（N-1）/2

　　当 N 的值很大时，算法比较次数约为 N²/2次比较，忽略减1。

　　假设数据是随机的，那么每次比较可能要交换位置，可能不会交换，假设概率为50%，那么交换次数为 N²/4。不过如果是最坏的情况，初始数据是逆序的，那么每次比较都要交换位置。

　　交换和比较次数都和N² 成正比。由于常数不算大 O 表示法中，忽略 2 和 4，那么冒泡排序运行都需要 O(N²) 时间级别。

　　其实无论何时，只要看见一个循环嵌套在另一个循环中，我们都可以怀疑这个算法的运行时间为 O(N²)级，外层循环执行 N 次，内层循环对每一次外层循环都执行N次（或者几分之N次）。这就意味着大约需要执行N²次某个基本操作。