冒泡排序及其优化

/**
 * 冒泡排序及其优化
 * @author shuaicenglou
 *
 */
public class Maopao {
    public static void main(String[] args) {
        int[] a = {4,3,2,1};
        long startTime = System.nanoTime();    //获取开始时间
        sort(a);
        long endTime = System.nanoTime();      //获取结束时间
        System.out.println("程序运行时间：" + (endTime - startTime) + "ns");    //输出程序运行时间
        //for(int i:a) System.out.println(i);
    }

    /**
     * 优化算法2：优化外层循环的同时优化内层循环,内层循环每次循环记录最后一次交换发生的位置pos,
     * 当下一次循环开始时,[0,pos-1]是未排好序的,[pos,n-1]是有序的（n为数组长度）,
     * 因为pos之后的数据没有发生交换，所以是有序的
     * 因此可以从0开始，到pos交换结束
     * 在最坏(完全逆序)情况下比较次数较优化算法1减少了50%,较原始算法比较次数减少75%
     * @param array
     */
    public static void sort2(int[] array){
        int n = array.length,pos=0,k=n;//pos记录最后发生交换的位置
        int num = 0;
        for(int i=0;i<n;i++){
            boolean flag = true;
            for(int j=0;j<k-1;j++){
                num+=1;
                if(array[j]>=array[j+1]){
                    int cache = array[j];
                    array[j] = array[j+1];
                    array[j+1] = cache;
                    flag = false;
                    pos = j;      //记录发生交换的位置
                }
            }
            k=pos+1;  //注意边界条件
            if(flag) break;
        }
        System.out.println("比较了"+num+"次");
    }
    /**
     * 优化算法1：使用标志位标记是否未发生交换，若未发生交换则提前结束循环
     * 比原始算法比较次数减少了25%
     * @param array
     */
    public static void sort(int[] array){
        int len = array.length;//记录数组长度
        int num=0;   //记录比较次数
        while(true){
            boolean flag = true;  //设置标志位
            for(int i=0;i<len-1;i++){
                num+=1;
                if(array[i]>=array[i+1]){
                    int mid = array[i];
                    array[i] = array[i+1];
                    array[i+1] = mid;
                    flag = false;
                }
            }
            if(flag) break;
        }
        System.out.println("比较了"+num+"次");
    }
}