冒泡排序算法

package com.sort;

/**
 * 冒泡排序算法
 * 比较相邻的元素，若是第一个比第二个大，就交换它们。
 * 对每一对相邻元素作一样的工做，从开始的第一对到结尾的最后一对，在这一点上，最后元素是最大的数。
 * 针对全部的元素重复以上的动做，除了最后一个元素。
 * 持续每次对愈来愈少的元素重复上面的动做，直到没有任何一对元素须要比较。
 * 
 *  时间复杂度
 * 平均状况：O(n2)， 最好状况：O(n)， 最坏状况：O(n2)
 * 
 * 空间复杂度
 * 辅助存储:O(1)
 * 
 * 稳定性：稳定
 */

public class BubbleSort{
	
	/**
	 * 
	* @Title: sort 
	* @Description: 假设数组长度为n，每完成一次大循环将最小的冒泡到上端，要完成全部元素排序，须要通过n次大循环，
	* 				小循环进行两两相邻元素对比，若是反序则交换位置，小循环从最后开始比较，次数逐次递减，
	* 				加入flag布尔变量改进冒泡算法，使其对有序数组的排序时间复杂度变为O(n)。
	*/
	public static void sort(Comparable[] a) {
		int compareNum = 0;
		int swapNum = 0;
		int size = a.length;
		boolean flag = true;
		
		for(int i=0; i<size && flag; i++) {      
			flag = false;
			for(int j=size-1; j>i; j--) {  
				System.out.println("compare num:" + (++compareNum));
				if(less(a[j], a[j-1])) {
					swap(a, j, j-1);
					flag = true;
					System.out.println("swap num:" + (++swapNum));
				}
			}
		}
	}
	
	public static void show(Comparable[] a) {
		for(int i=0; i<a.length; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}
	
	private static boolean less(Comparable v, Comparable w) {
		return v.compareTo(w) < 0;
	}
	
	private static  void swap(Comparable[] a, int i, int j) {
		Comparable t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
	
	public static void main(String[] args) {
		Integer a[] = {23, 44, 56, 91, 2, 0, 81,100, 3, 17};  
		Integer b[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
		
		//无序数组排序
		sort(a);
		show(a);
		
		//有序数组排序
		sort(b);
		show(b);
	}
}