0.如果遇到相等的值不進行交換，那這種排序方式是穩定的排序方式。

1.原理：比較兩個相鄰的元素，將值大的元素交換到右邊

2.思路：依次比較相鄰的兩個數，將比較小的數放在前面，比較大的數放在後面。

　　　　(1)第一次比較：首先比較第一和第二個數，將小數放在前面，將大數放在後面。

　　　　(2)比較第2和第3個數，將小數 放在前面，大數放在後面。

　　　　......

　　　　(3)如此繼續，知道比較到最後的兩個數，將小數放在前面，大數放在後面，重複步驟，直至全部排序完成

　　　　(4)在上面一趟比較完成後，最後一個數一定是陣列中最大的一個數，所以在比較第二趟的時候，最後一個數是不參加比較的。

　　　　(5)在第二趟比較完成後，倒數第二個數也一定是陣列中倒數第二大數，所以在第三趟的比較中，最後兩個數是不參與比較的。

　　　　(6)依次類推，每一趟比較次數減少依次

3.舉例：

　　　　(1)要排序陣列:[10,1,35,61,89,36,55]

　　　　(2)第一趟排序：

　　　　　　第一次排序：10和1比較，10大於1，交換位置　　　 [1,10,35,61,89,36,55]

　　　　　　第二趟排序：10和35比較，10小於35，不交換位置　　[1,10,35,61,89,36,55]

　　　　　　第三趟排序：35和61比較，35小於61，不交換位置　　[1,10,35,61,89,36,55]

　　　　　　第四趟排序：61和89比較，61小於89，不交換位置　　[1,10,35,61,89,36,55]

　　　　　 第五趟排序：89和36比較，89大於36，交換位置　　　[1,10,35,61,36,89,55]

　　　　　　第六趟排序：89和55比較，89大於55，交換位置　　　[1,10,35,61,36,55,89]

　　　　　　第一趟總共進行了六次比較，排序結果：[1,10,35,61,36,55,89]

　　　　(3)第二趟排序：

　　　　　　第一次排序：1和10比較，1小於10，不交換位置　　1,10,35,61,36,55,89

　　　　　　第二次排序：10和35比較，10小於35，不交換位置 1,10,35,61,36,55,89

　　　　　　第三次排序：35和61比較，35小於61，不交換位置 1,10,35,61,36,55,89

　　　　　　第四次排序：61和36比較，61大於36，交換位置　　　1,10,35,36,61,55,89

　　　　　　第五次排序：61和55比較，61大於55，交換位置　　　1,10,35,36,55,61,89

　　　　　　第二趟總共進行了5次比較，排序結果：1,10,35,36,55,61,89

　　　　(4)第三趟排序：

　　　　　　1和10比較，1小於10，不交換位置　　1,10,35,36,55,61,89

　　　　　　第二次排序：10和35比較，10小於35，不交換位置 1,10,35,36,55,61,89

　　　　　　第三次排序：35和36比較，35小於36，不交換位置 1,10,35,36,55,61,89

　　　　　　第四次排序：36和61比較，36小於61，不交換位置　　　1,10,35,36,55,61,89

　　　　　　第三趟總共進行了4次比較，排序結果：1,10,35,36,55,61,89

　　　　　　到目前位置已經為有序的情形了。

4.演算法分析：

　　　　(1)由此可見：N個數字要排序完成，總共進行N-1趟排序，每i趟的排序次數為(N-i)次，所以可以用雙重迴圈語句，外層控制迴圈多少趟，內層控制每一趟的迴圈次數

　　　　(2)氣泡排序的優點：每進行一趟排序，就會少比較一次，因為每進行一趟排序都會找出一個較大值。如上例：第一趟比較之後，排在最後的一個數一定是最大的一個數，第二趟排序的時候，只需要比較除了最後一個數以外的其他的數，同樣也能找出一個最大的數排在參與第二趟比較的數後面，第三趟比較的時候，只需要比較除了最後兩個數以外的其他的數，以此類推……也就是說，沒進行一趟比較，每一趟少比較一次，一定程度上減少了演算法的量。

　　　　(3)時間複雜度

　　　　1.如果我們的資料正序，只需要走一趟即可完成排序。所需的比較次數C和記錄移動次數M均達到最小值，即：C_min=n-1;M_min=0;所以，氣泡排序最好的時間複雜度為O_(n)。

　　　　2.如果很不幸我們的資料是反序的，則需要進行n-1趟排序。每趟排序要進行n-i次比較(1≤i≤n-1)，且每次比較都必須移動記錄三次來達到交換記錄位置。在這種情況下，比較和移動次數均達到最大值：

　　　　　　綜上所述：氣泡排序總的平均時間複雜度為：O_(n²),時間複雜度和資料狀況無關。

5.java程式碼實現，程式碼的實現用到了對數發生器

import java.util.Arrays;
//演算法的最終時間複雜度為n^2
public class BubbleSort {
    public static void main(String[] args) {
        int testTime=500000;
        int size = 10;
        int value=100;
        boolean succeed = true;
        for(int i = 0 ;i<testTime;i++){
            int[] arr1 = generateRandomArray(size,value);
            int[] arr2 = copyArray(arr1);
            int[] arr3= copyArray(arr1);
            bubbleSort(arr1);
            rightMethod(arr2);
            if(!isEqual(arr1,arr2)){
                succeed=false;
                printArray(arr3);
                break;
            }
        }
        System.out.println(succeed?"Nice":"Fucking fucked!");
        int[] arr= generateRandomArray(size,value);
        printArray(arr);
        bubbleSort(arr);
        printArray(arr);
    }
    //產生一個隨機陣列，陣列的長度和值都是隨機的，
    public static  int[] generateRandomArray(int size,int value){
        //在java中，Math.random() ->double(0,1)
        //(int)((size+1)*Math.random())--->產生的是[0,size]之間的整數
        //生成長度隨機的陣列，陣列的最大長度是size的長度
        int[] arr = new int[(int)((size+1)*Math.random())];
        for(int i = 0 ;i<arr.length;i++){
            //針對陣列中的每個值都可以隨機一下，一個隨機數減去另外一個隨機數，可能產生正數，也可能產生負數
            arr[i]=(int)((value+1)*Math.random())-(int)(value*Math.random());//值也可以是隨機的
        }
        return arr;
    }
    //複製陣列
    public static int[] copyArray(int[] arr){
        if(arr==null){
            return null;
        }
        int[] res = new int[arr.length];
        for(int i = 0 ;i<arr.length;i++){
            res[i]=arr[i]  ;
        }
        return res;
    }
    //絕對正確的方法,這個方法可以時間複雜度很差，但是要保證其準確性
    public static void rightMethod(int[] arr){
        Arrays.sort(arr);
    }
    //
    public static boolean isEqual(int[] arr1,int[] arr2){
        if(arr1==null&&arr2!=null||arr1!=null&&arr2==null){
            return false;
        }
        if (arr1==null&&arr2==null){
            return true;
        }
        if (arr1.length!=arr2.length){
            return false;
        }
        for(int i = 0;i<arr1.length;i++){
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    //打印出陣列
    public static void printArray(int[] arr){
        if(arr==null){
            return;
        }
        for(int i = 0 ;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

    //N個數字氣泡排序，總共要進行N-1趟比較，每趟的排序次數為(N-i)次比較
    public static void bubbleSort(int[] arr){
        //一定要記住判斷邊界條件，很多人不注意這些細節，面試官看到你的程式碼的時候都懶得往下看，你的程式碼哪個專案敢往裡面加？
        if(arr==null||arr.length<2){
            return;
        }
        //需要進行arr.length趟比較

        for(int i = 0 ;i<arr.length-1;i++){
            //第i趟比較
            for(int j = 0 ;j<arr.length-i-1;j++){
                //開始進行比較，如果arr[j]比arr[j+1]的值大，那就交換位置
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }

        }
//        System.out.println("最終得出的陣列為：");
//        for (int k =0 ; k < arr.length;k++){
//            System.out.print(arr[k]+" ");
//        }
    }

    //生成一個對數器。產生一個隨機樣本的陣列，陣列的長度和值都是隨機的
    //size是生成陣列的最大長度
//    public static int[] generateRandomArray(int size,int value){
//        //生成長度隨機的陣列
//        int[] arr = new int[(int)((size+1)*Math.random())];
//        for(int i = 0 ;i<arr.length;i++){
//            arr[i]=(int)((value+1)*Math.random())-(int)(value*Math.random());
//        }
//        return arr;
//    }

    //for test
    public static  void rightMathods(int[] arr){
        //呼叫系統呼叫的函式來進行驗證
        Arrays.sort(arr);
    }



}