Java内部排序（三）-（交换排序法之冒泡排序）

对于包含n个数据的一组记录，在最坏的情况下，冒泡排序需要进行n-1趟比较。

第一趟：依次比较 0 和 1、 1 和 2、2 和 3、……n-2 和 n-1索引处的元素，如果发现第一个数据大于后一个数据，则交换他们。经过第一趟比较，最大的元素排在最后。

第二趟：依次比较 0 和 1、 1 和 2、2 和 3、……n-3 和 n-2索引处的元素，如果发现第一个数据大于后一个数据，则交换他们。经过第二趟比较，第二大的元素排在倒数第二位。

……

第n-1趟：依次比较 0 和 1 索引处的元素，如果发现第一个数据大于后一个数据，则交换他们。经过第n-1趟比较，第二小的数组排在了第二位。

模拟冒泡排序：

假设有数据：9,16,21*，23，30，49，21，30*

public class BubbleSort {
	public static void bubbleSort(DataWrap[] data){
		System.out.println( "-开始排序-");
		int arrayLength = data.length;
		
		//进行 n-1 趟比较
		for(int i = 0; i < arrayLength - 1; i ++){
			boolean flag = false;
			for(int j = 0; j < arrayLength - i - 1; j ++){
				if(data[j].compareTo(data[j + 1]) > 0){
					wrap(data, j, j+1);
					flag = true;
				}
			}
			//每趟比较后输出结果
			System.out.println(java.util.Arrays.toString(data));
			//如果哪趟没有发生交换，说明序列已经是有序状态，结束循环
			if(!flag){
				break;
			}
		}
	}
	
	public static void wrap(DataWrap[] data, int i, int j){
		DataWrap dw = data[i];
		data[i] = data[j];
		data[j] = dw;
	}
	
	public static void main(String[] args){
		//9,16,21*，23，30，49，21，30*
		DataWrap[] data = {new DataWrap(9,""),
							new DataWrap(16,""),
							new DataWrap(21,"*"),
							new DataWrap(23,""),
							new DataWrap(30,""),
							new DataWrap(49,""),
							new DataWrap(21,""),
							new DataWrap(30,"*")};
		System.out.println("-排序前-"+java.util.Arrays.toString(data));

		bubbleSort(data);
		
		System.out.println("-排序后-"+java.util.Arrays.toString(data));

	}
}

运行结果：

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

冒泡排序算法的空间效率非常高，为 O(1)。

从上面的输出结果来看冒泡排序算法是稳定的。

参考资料：《疯狂Java程序员的基本修养》   --李刚

《Java算法》（第三版，第一卷）