排序之冒泡排序

冒泡排序思想

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

---

代码实现

package sort;

public class BubbleSort {
    public static void bubbleSort(int[] data) {
        if (data == null || data.length <=1) {
            return;
        }

//i表示的是排序趟数，也表示了每次排序的边界
        for (int i = data.length - 1; i >= 1; i--) {
            for (int j = 1; j <= i; j++) {
                if (data[j - 1] > data[j]) {
                    swap(data, j - 1, j);
                }
            }
        }
        return;
    }

    private static void swap(int[] data, int p, int q) {
        if (data == null || data.length <= 0 || p < 0 || q < 0 || data.length <= p || data.length <= q) {
            throw new IllegalArgumentException("Invalid parameters in swap method!");
        }
        int tmp = data[p];
        data[p] = data[q];
        data[q] = tmp;
    }
}

---

性能分析：稳定

时间复杂度：O(n^2)

---

冒泡排序算法的改进

改进一：设置标志性变量exchange

对冒泡排序常见的改进方法是加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换，如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。

public static void bubbleSort2(int[] data) {
        if (data == null || data.length <=1) {
            return;
        }

        boolean exchange = true;
        for (int i = data.length - 1; i >= 1 && exchange; i--) {
            exchange = false;
            for (int j = 1; j <= i; j++) {
                if (data[j - 1] > data[j]) {
                    swap(data, j - 1, j);
                    exchange = true;
                }
            }
        }
        return;
    }

最好情况的时间复杂度是：O(n)

改进二：正向和反向两遍冒泡

传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

public static void bubbleSort3(int[] data) {
        if (data == null || data.length <=1) {
            return;
        }

        int low = 0;
        int high = data.length - 1;
        int tmp, j;
        while (low < high) {
            for (j = low; j < high; ++j) //正向冒泡,找到最大者
                if (data[j] > data[j+1]) {
                    tmp = data[j]; data[j] = data[j + 1]; data[j + 1] = tmp;
                }
            --high;                 //修改high值, 前移一位
            for (j = high; j > low; --j) //反向冒泡,找到最小者
                if (data[j] < data[j-1]) {
                    tmp = data[j]; data[j] = data[j - 1]; data[j - 1] = tmp;
                }
            ++low;                  //修改low值,后移一位
        }
        return;
    }

排序趟数几乎减少了一半,但是每趟元素比较的次数增多。
时间复杂度仍然是：O(n^2)