一、概述：本文主要介紹常見的幾種排序算法的原理以及java實現，包括：冒泡排序、選擇排序、插入排序、快速排序、歸並排序等。

二、冒泡排序：

（1）原理：

　　1、從第一個數據開始，與第二個數據相比較，如果第二個數據小於第一個數據，則交換兩個數據的位置。

　　2、指針由第一個數據移向第二個數據，第二個數據與第三個數據相比較，如果第三個數據小於第二個數據，則交換兩個數據的位置。

　　3、依此類推，完成第一輪排序。第一輪排序結束後，最大的元素被移到了最右面。

　　4、依照上面的過程進行第二輪排序，將第二大的排在倒數第二的位置。

　　5、重復上述過程，沒排完一輪，比較次數就減少一次。

（2）例子：

待排序數據：7, 6, 9, 8, 5,1

第一輪排序過程：指針先指向7，7和6比較，6<7，交換6和7的位置，結果為：6,7,9,8,5,1

　　　　　　　　指針指向第二個元素7，7和9比較，9>7，不用交換位置，結果仍為：6,7,9,8,5,1

　　　　　　　　指針指向第三個元素9，比較9和8，8<9，交換8和9的位置，結果為：6,7,8,9,5,1

　　　　　　　　指針指向第四個元素9，比較9和5，5<9，交換5和9，結果為：6,7,8,5,9,1

　　　　　　　　指針指向第五個元素9，比較9和1，1<9，交換1和9的位置，結果為6,7,8,5,1,9

第一輪排序結束後，最大的數字9被移到了最右邊。

進行第二輪排序，過程同上，只是由於最大的9已經放在最右邊了，因此不用在比較9了，少了一次比較，第二輪結束的結果為：6,7,5,1,8,9

第三輪結果：6,5,1,7,8,9

第四輪比較結果：5,1,6,7,8,9

第五輪比較結果：1,5,6,7,8,9

最終排序結果為：1,5,6,7,8,9，由上可知N個數據排序，需要進行N-1輪排序；第i輪排序需要的比較次數為N-i次。

（3）編碼思路：

　　需要兩層循環，第一層循環i表示排序的輪數，第二層循環j表示比較的次數。

（4）代碼實現：

package com.test.insertsort;
/**
 * 冒泡排序
 * @author bjh
 *
 
 
*/
public class BobSort {
    
    private int[] array;
    private int length;
    
    /**
     * 構造函數
     * @param array
     */
    public BobSort(int[] array){
        this.array = array;
        this.length = array.length;
    }
    
    /**
     * 打印數組中數據
     */
    public void display(){
        for(int i : array){
            System.out.print(i+" ");
        }
        System.out.println();
    }
    
    /**
     * 冒泡排序
     */
    public void bobSort(){
        for(int i=0;i<length-1;i++){//排序輪數
            for(int j=0;j<length-1-i;j++){//比較次數
                if(array[j]>array[j+1]){
                    int temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
            this.display();
        }
    }
    
    /**
     * 測試方法
     * @param args
     */
    public static void main(String[] args){
        int[] array = {77,29,28,36,33,25,10};
        BobSort bobSort = new BobSort(array);
        System.out.println("排序前的數據為：");
        bobSort.display();
        bobSort.bobSort();
        System.out.println("排序後的數據為：");
        bobSort.display();
    }
}

（5）冒泡排序算法總結：

　　N個元素需要排序N-1輪；

　　第i輪需要比較N-i次；

　　N個元素排序，需要比較n（n-1）/2次；

　　冒泡排序的算法復雜度較高，為O（n*n）

java實現排序算法：快排、冒泡排序、選擇排序、插入排序、歸並排序