内部排序算法系列---冒泡排序

冒泡排序思路比较简单，直接看程序吧。

冒泡排序的每趟交换结束后，不仅能够将最大值挤出最后面位置，还能部分理顺前面的其他元素；一旦某躺没有交换发生，即可提前结束排序。

import java.util.Arrays;

/**
 * @author stefanie zhao
 * @date 2014-9-29 下午02:11:21
 */
public class BubbleSort {

    //DataWrap类见其他排序博客中
    public static void bubbleSort(DataWrap[] data) {
        System.out.println("begin  sort....");
        int arrayLength = data.length;
        // 循环建堆
        for (int i = 0; i < arrayLength - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < arrayLength - 1 - i; j++) {
                if (data[j].compareTo(data[j + 1]) > 0) {
                    DataWrap tmp = data[j + 1];
                    data[j + 1] = data[j];
                    data[j] = tmp;
                    flag = true;
                }
            }
            System.out.println(Arrays.toString(data));
            if (!flag)
                break;
        }
    }

    public static void main(String[] args) {
        DataWrap[] data = { new DataWrap(23, ""), new DataWrap(13, ""), new DataWrap(43, ""), new DataWrap(9, ""),
                new DataWrap(3, ""), new DataWrap(34, "") };
        System.out.println("before sort: \n" + Arrays.toString(data));
        bubbleSort(data);
        System.out.println("after sort: \n" + Arrays.toString(data));
    }

}

运行结果：

before sort:
[23, 13, 43, 9, 3, 34]
begin  sort....
[13, 23, 9, 3, 34, 43]
[13, 9, 3, 23, 34, 43]
[9, 3, 13, 23, 34, 43]
[3, 9, 13, 23, 34, 43]
[3, 9, 13, 23, 34, 43]
after sort:
[3, 9, 13, 23, 34, 43]

总结：

时间效率是不确定的，在最好的情况下，初始数据已经处于有序状态，执行1趟冒泡排序即可，做n-1次比较，无需进行任何交换；但在最坏的情况下，初始数据处于完全逆序状态，算法要执行n-1趟冒泡，第i趟做了n-i次比较，执行n-i-1次对象交换。此时的比较总次数为n*(n-1)/2,记录移动总次数n*(n-1)*3/2。空间效率很高为O(1)。