冒泡排序性能優化詳解

一、雙重循環  

第一層for循環 控制排序的輪數回合的趟數，第二層相鄰元素兩兩比較，交換元素，ints.length-i-1爲無序數列的邊界，隨着趟數的變大，是不斷縮小的

import java.util.Arrays;

public class BubbleSort_1 {
    //冒泡排序
    public static void sort(int[] ints){

        int temp = 0;
        //第一層for循環 控制排序的輪數回合的趟數
        for(int i=0;i<ints.length;i++){
            //第二層相鄰元素兩兩比較，交換元素，ints.length-i-1爲無序數列的邊界，隨着趟數的變大，是不斷縮小的
            for(int j=0;j<ints.length-i-1;j++){
                if(ints[j] > ints[j+1]){
                    temp = ints[j];
                    ints[j]=ints[j+1];
                    ints[j+1]=temp;

                }
            }
        }
    }
    public static  void  main(String[] args){
        int[] arg = {7,8,9,4,1,2,5,3,6};
        sort(arg);
        System.out.print(Arrays.toString(arg));
    }
}

二、

改進一：由數列的長度來決定輪數，其實到第六輪排序，已經是有序的了，排序算法仍然執行第七、第八趟的比較。
解決：利用boolean 變量標記，如果沒有數據交換，說明數列有序，跳出大循環

import java.util.Arrays;

public class BubbleSort_2 {
    //冒泡排序
    //缺點一：由數列的長度來決定輪數，其實到第六輪排序，已經是有序的了，排序算法仍然執行第七、第八趟的比較。
    //解決：利用boolean 變量標記，如果沒有數據交換，說明數列有序，跳出大循環
    public static void sort(int[] ints){

        int temp = 0;
        boolean flag = false;
        for(int i=0;i<ints.length;i++){
            for(int j=0;j<ints.length-i-1;j++){
                if(ints[j] > ints[j+1]){
                    temp = ints[j];
                    ints[j]=ints[j+1];
                    ints[j+1]=temp;
                    //有元素交換，所以不是有序的
                    flag = true;
                }
            }
            //如果無元素交換，都是有序的，直接跳出循環
            if(!flag){
                break;
            }
        }
    }
    public static  void  main(String[] args){
        int[] arg = {3,4,2,1,5,6,7,8};
        sort(arg);
        System.out.print(Arrays.toString(arg));
    }
}

 三、

改進二：如果原來數列最後的元素已經是有序的，比如{4,1,2,5,3,6,7,8,9}，可是每一輪都還是進行了比較。 解決：關鍵對於數列的有序區界定，我們在每一輪排序的最後，記錄最後一次交換的位置，這個位置就是無序數列的邊界。往後就是有序區了。

import java.util.Arrays;

public class BubbleSort{
    //冒泡排序
    //缺點二：如果原來數列最後的元素已經是有序的，比如{4,1,2,5,3,6,7,8,9}，可是每一輪都還是進行了比較。
    //解決：關鍵對於數列的有序區界定，我們在每一輪排序的最後，記錄最後一次交換的位置，這個位置就是無序數列的邊界。往後就是有序區了。
    public static void sort(int[] ints){
        //記錄最後一次交換的位置
        int lastIndex = 0;
        //無序數列的邊界，每次比較只要比較到這裏
        int bubble = ints.length - 1;
        int temp = 0;
        boolean flag = false;
        for(int i=0;i<ints.length;i++){
            for(int j=0;j<bubble;j++){
                if(ints[j] > ints[j+1]){
                    temp = ints[j];
                    ints[j]=ints[j+1];
                    ints[j+1]=temp;
                    flag = true;
                    //把無序數列的邊界更新爲最後一次交換的位置
                    lastIndex = j;
                }
            }
         bubble = lastIndex;
            if(!flag){
                break;
            }
        }
    }
    public static  void  main(String[] args){
        int[] arg = {4,1,2,5,3,6,7,8,9};
        sort(arg);
        System.out.print(Arrays.toString(arg));
    }
}

 

 

轉載自 https://mp.weixin.qq.com/s/GrOzv30dM717gcA1FquiHw