冒泡排序bubble sort

一、冒泡排序的基本思想；

集合S = {s0, s1, ..., sn}

第一趟排序范围从s0到sn，相邻的两个数si, sj比较，如果si > sj，大的数排在小的数的后面；降序排序则相反。

集合进行第一趟比较后，最大的数排在最后的位置n；

第二趟排序范围从s0到sn-1，进行两两比较，

第二趟比较完后，最大的数排在倒数第二位置n-1；

...

排序的范围直到只剩下s0，则顺序就排好了。

时间复杂度O(n * n)

如例子：

[2, 7, 3, 6, 5, 1]

第一趟冒泡：

从0 到 5 位数中，最大数是7，7排到最后一位

[2, 3, 6, 5, 1, 7]

第二趟冒泡：

从0 到 4 位数中，最大数是6 ，6排到第4位

[2, 3, 5, 1, 6, 7]

第三趟冒泡：

从0 到 3 位数中，最大数是4 ，5排到第3位

[2, 3, 1, 5, 6, 7]

第四趟冒泡：

从0 到 2 位数中，最大数是2 ，3排到第2位

[2, 1, 3, 5, 6, 7]

第五趟冒泡：

从0 到 1 位数中，最大数是2 ，2排到第1位

[1, 2, 3, 5, 6, 7]

第六趟冒泡：

从0 到 0 位数中，只剩下一位数排序，排序结束。

二、冒泡算法的java实现

public class BubbleSort {
	
	/**
	 * 集合S = {s0, s1, ..., sn}
	 * 从s0开始，相邻的两个数比较，如果升序排序则大的数排在小的数的后面，降序排序则相反。
	 * 全部数第一趟比较后，最大的数排在最后一位，同样又从第一个数开始两两比较，最大的数排在倒数第二...直到只剩下s0。
         * ascend:true 升序,  false 降序
        */
	public void sort(int[] ints, int fromIndex, int toIndex, boolean ascend){
		if(ints == null){
			throw new NullPointerException("int array inst is null.");
		}
		if(fromIndex < 0 || fromIndex > toIndex || toIndex > ints.length - 1){
			throw new IndexOutOfBoundsException("array size(" + ints.length + "), "
					+ "fromIndex(" + fromIndex + "), toIndex(" + toIndex + ") out of bound.");
		}
		int swap;
		int fromIndex_ = fromIndex;
		for(; fromIndex_ < toIndex; fromIndex_++){
			if(ints[fromIndex_] > ints[fromIndex_ + 1]){
				if(ascend){
					swap = ints[fromIndex_];
					ints[fromIndex_] = ints[fromIndex_ + 1];
					ints[fromIndex_ + 1] = swap;					
				}
			}else if(ints[fromIndex_] < ints[fromIndex_ + 1]){
				if(!ascend){
					swap = ints[fromIndex_ + 1];
					ints[fromIndex_ + 1] = ints[fromIndex_];
					ints[fromIndex_] = swap;
				}
			}
		}
		System.out.println(Arrays.toString(ints));
		if(fromIndex < toIndex - 1){
			sort(ints, fromIndex, toIndex - 1, ascend);
		}
	}
	
	public static void main(String[] args){
		int[] ints = {2, 7, 3, 6, 5, 1};		
		System.out.println(Arrays.toString(ints));
		
		new BubbleSort().sort(ints, 0, ints.length - 1, true);
	}

}

...