排序算法系列——冒泡排序

冒泡排序是交换排序的一种，其思想是从序列头部开始逐步往后遍历，每次遍历比较相邻两个元素，如果顺序不对则交换，n-1次遍历之后序列就完成了排序。由于每次遍历都是把最大的元素一步步让最后移动，类似于水泡慢慢浮出水面，于是得名冒泡算法。冒泡算法的思想很简单，实现起来也很容易，但是效率太低，所以即使是小数据量也很少推荐使用冒泡算法，更多的使用直接插入排序。
基本思想：
从待排序序列头部开始循环遍历n-1次，每次遍历比较相邻两个元素，如果顺序不对则交换，也就是说如果你想要从小到大排列，那么如果相邻两个元素比较结果是前面的大于后面的，则交换就可以了，那么通过一次遍历最大的元素就到达了序列的尾部，n-1次遍历之后序列就完成了排序。这里显然有可优化的空间，下面会提到。
实现要点：
第i次(i=0…n-1)遍历从0开始比较到n-1-i(n序列长度)，因为每次遍历都会将未排序部分最大的元素移动到序列尾部，所以序列尾部是有序的，故在之后的遍历过程中无需继续比较有序的部分。
算法改进：
该算法有两处可优化的地方：

• 如果一次遍历过程中未发生任何交换，即所有相邻元素的顺序都是正确的，则说明整个序列已经完成排序，故无需继续遍历。
• 每次遍历过程中记录下最后一次发生遍历的位置，则在改位置之后的部分已经是有序的，下次遍历时就可以提前结束。

实验表明以上两种改进之后的效率并未有太大的提高，第一种改进效率反而比为改进的低，第二种改进效率稍微提高一点点。虽然这两种改进从理论上来看是有一定的优化的，但是测试时使用的序列一般都是随机的，即在n-1次遍历之前完成排序以及部分有序的可能性都很小，所以这两种改进的效果都不是很明显，可能根本不会发生，反而由于加入了一些逻辑判断反而导致效率降低。不过如果是真是数据，那么之前提到的两种情况还是很可能发生的。

Java实现：

package com.vicky.sort;

import java.util.Random;

/**
 * 交换排序：冒泡排序
 * 
 * 时间复杂度：O(n^2)
 * 
 * 空间复杂度：O(1)
 * 
 * 稳定性：稳定
 * 
 * @author Vicky
 * 
 */
public class BubbleSort {

    /**
     * 未改进的冒泡排序
     * 
     * @param <T>
     * @param data
     */
    public static <T extends Comparable<T>> void sort(T[] data) {
        long start = System.nanoTime();
        if (null == data) {
            throw new NullPointerException("data");
        }
        if (data.length == 1) {
            return;
        }
        // n-1趟遍历
        for (int i = 0; i < data.length - 1; i++) {
            // 每次遍历从0开始依次比较相邻元素
            for (int j = 0; j < data.length - 1 - i; j++) {
                // 前面元素>后面元素则交换
                if (data[j].compareTo(data[j + 1]) > 0) {
                    T temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
        }
        System.out.println("sort, use time:" + (System.nanoTime() - start)
                / 1000000);
    }

    /**
     * 改进后冒泡排序
     * 
     * 改进原理：如果一次遍历过程未发生交换，则说明序列已经是有序的，故无需再进行遍历。
     * 
     * @param <T>
     * @param data
     */
    public static <T extends Comparable<T>> void sortImprove(T[] data) {
        long start = System.nanoTime();
        if (null == data) {
            throw new NullPointerException("data");
        }
        if (data.length == 1) {
            return;
        }
        boolean exchange = false;// 记录一趟遍历是否发生交换
        // n-1趟遍历
        for (int i = 0; i < data.length - 1; i++) {
            // 每次遍历从0开始依次比较相邻元素
            for (int j = 0; j < data.length - 1 - i; j++) {
                // 前面元素>后面元素则交换
                if (data[j].compareTo(data[j + 1]) > 0) {
                    T temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                    exchange = true;
                }
            }
            // 如果本次遍历未发生交换，则说明序列已是有序的，则无需继续遍历
            if (!exchange) {
                return;
            }
        }
        System.out.println("sortImprove1, use time:"
                + (System.nanoTime() - start) / 1000000);
    }

    /**
     * 改进后冒泡排序
     * 
     * 改进原理：在冒泡排序的每趟扫描中，记住最后一次交换发生的位置lastexchange也能有所帮助。因为该位置之后的部分已经是有序的(未发生交换，
     * 所以是有序)，
     * 故下一趟排序开始的时候，只需处理0到lastexchange部分，lastexchange到n-1是有序区。同时如果未发生交换则退出即可
     * 
     * @param <T>
     * @param data
     */
    public static <T extends Comparable<T>> void sortImprove2(T[] data) {
        long start = System.nanoTime();
        if (null == data) {
            throw new NullPointerException("data");
        }
        if (data.length == 1) {
            return;
        }
        int lastChange = data.length - 1;// 记录一趟遍历最后一次发生交换的位置，该位置之后是有序的
        // 上次遍历发生交换则lastChange>0，继续遍历
        while (lastChange > 0) {
            // 本次遍历从0开始到上次遍历最后一次交换的位置结束
            int end = lastChange;
            lastChange = 0;
            // 每次遍历从0开始依次比较相邻元素
            for (int j = 0; j < end; j++) {
                // 前面元素>后面元素则交换
                if (data[j].compareTo(data[j + 1]) > 0) {
                    T temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                    lastChange = j + 1;
                }
            }
        }
        System.out.println("sortImprove2, use time:"
                + (System.nanoTime() - start) / 1000000);
    }

    public static void main(String[] args) {
        // 用于记录三种冒泡排序的用时
        long[] useTime1 = new long[10];
        long[] useTime2 = new long[10];
        long[] useTime3 = new long[10];
        // 循环测试10次，取均值
        for (int times = 0; times < 10; times++) {
            // 构建10000个元素的序列进行排序
            Random ran = new Random();
            Integer[] data = new Integer[10000];
            for (int i = 0; i < data.length; i++) {
                data[i] = ran.nextInt(10000000);
            }
            // 使用System.arraycopy复制三个数组分别用于排序
            Integer[] data1 = new Integer[data.length];
            Integer[] data2 = new Integer[data.length];
            Integer[] data3 = new Integer[data.length];
            System.arraycopy(data, 0, data1, 0, data.length);
            System.arraycopy(data, 0, data2, 0, data.length);
            System.arraycopy(data, 0, data3, 0, data.length);
            // 分别记录三种冒泡排序的用时
            long start = System.nanoTime();
            BubbleSort.sort(data1);
            useTime1[times] = (System.nanoTime() - start) / 1000000;
            // SortUtils.printArray(data1);
            start = System.nanoTime();
            BubbleSort.sortImprove(data2);
            useTime2[times] = (System.nanoTime() - start) / 1000000;
            start = System.nanoTime();
            // SortUtils.printArray(data2);
            BubbleSort.sortImprove2(data3);
            useTime3[times] = (System.nanoTime() - start) / 1000000;
            // SortUtils.printArray(data3);
        }
        // 计算用时最大值，最小值，均值
        long[] res1 = SortUtils.countArray(useTime1);
        long[] res2 = SortUtils.countArray(useTime2);
        long[] res3 = SortUtils.countArray(useTime3);
        System.out.println("method\tmax\tmin\tavg\t");
        System.out.println("sort" + "\t" + res1[0] + "\t" + res1[1] + "\t"
                + res1[2]);
        System.out.println("sortImprove" + "\t" + res2[0] + "\t" + res2[1]
                + "\t" + res2[2]);
        System.out.println("sortImprove2" + "\t" + res3[0] + "\t" + res3[1]
                + "\t" + res3[2]);
        // 测试结果，第一种改进方法效率比不改进还差一些，
        // 可能由于出现提前完成排序的可能性较小，每次遍历加入了过多的赋值以及判断操作导致效率反而降低
        // 第二种改进方法还是有一些效果的
        // method max min avg
        // sort 1190 1073 1123
        // sortImprove 1258 1097 1146
        // sortImprove2 1205 1056 1099
    }
}

效率分析：
（1）时间复杂度
O(n^2)
冒泡排序最好的时间复杂度是O(n)，一次遍历即可，无需交换（第一种改进）。最坏情况需要遍历n-1次，比较且交换n-1-i次，故时间复杂度是O(n^2)。
（2）空间复杂度
O(1)
从空间来看，它只需要一个元素的辅助空间，用于元素的位置交换O(1)。
（3）稳定性
稳定
排序过程中只有相邻两个元素会发生交换，同时为了减少交换次数相同的元素不会进行交换，所以两个相同元素的相对位置不会发生改变。