冒泡排序，冒泡性能優化--java實現

冒泡排序說明：

一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。

重復地進行直到沒有再需要交換，也就是說已經排序完成。

越小的元素會經由交換慢慢“浮”到數列的頂端。

冒泡排序算法的運作如下:

1.  比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2.  對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該會是最大的數。
3.  針對所有的元素重復以上的步驟，除了最后一個。
4.  持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

簡單的冒泡排序代碼：

import java.util.Arrays;

/**
 * 實現冒泡排序
 * @author dell
 *
 */
public class BubbleSort {

    public static void main(String[] args) {
        int[] arr = {1,200,19,55,10,22,3,7};
        //API實現
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //冒泡實現
        int temp;
        for(int i =0;i<arr.length-1;i++){
            for(int j = 0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

---

冒泡排序的性能分析和算法優化（外層循環優化）

問題：

有的冒泡經過第一輪的交換已經是有序的了，如：2 1 3 4。數據越多的時候越慢，非常不適合大數據的排序

解決辦法

如果用一個flag來判斷一下，當前數組是否已經有序，如果有序就退出循環，這樣可以明顯的提高冒泡排序的性能。

 

package bubbleSort;

import java.util.Arrays;

import org.junit.Test;

/**
 * 冒泡排序的性能分析和算法優化（外層循環優化）
 * @author dell
 *
 */
public class BubbeSort02 {

    @Test
    public void test1(){
        boolean flag = true;
        int[] arr = {2,1,3,4,5};
        int temp;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    flag=false;
                }
            }
            if(!flag){
                //沒有發生交換則退出循環；
                break;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

冒泡排序第二種優化（內層循環優化）

    /**
     * 冒泡排序的性能分析和算法優化（內層循環優化）
     */
    @Test
    public void test2(){
        
        int[] arr = {22,1,10,5};
        
        //標記最后一次交換的位置
        
        
        for (int i = 0; i < arr.length-1; i++) {
            int flag = 0;
            int temp;
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    //當位置發生改變，flag的值就發生變化
                    flag=1;
                }
            }
            //判斷標志位flag有沒有發生變化，沒有就直接結束內層循環
            if(flag==0){
                return;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

 

參考鏈接

http://blog.csdn.net/pzhtpf/article/details/7560294

http://www.jianshu.com/p/ffcf5f97bc36