組的排序方法非常多，其中有封裝好的sort()方法，也有js原生語句實現的冒泡排序、快速排序和選擇排序等算法。以下介紹冒泡排序的算法。

var arr=[6,5,4,3,2,1];實現從小到大排序

冒泡排序：數組內前后兩兩比較，如果前者大于后者，則交換兩者位置，直到所有的元素都按照從小到大排列，結束排序。

原理：兩兩比較，始終將較大的數放在后面

代碼

var arr=[6,5,4,3,2,1];
   //執行arr.length-1次循環，因為每次循環都會固定一位最大的數放在最后位置，當第五次循環時，結果會將最大的數放在arr[1],排序結束
   for(var i=0;i<arr.length-1;i++){
   //決定每輪元素比較多少次，當每次輪結束時，會將最大的數放在最后，下一輪比較時，最后固定的較大的數可以不再比較，所以j<arr.length-1-i.
     for(var j=0;j<arr.length-1-i;j++){
   //每次比較時，如果前者大于后者，則調換二者位置
       if(arr[j]>arr[j+1]){
         //兩個元素互換值，應該定義第三變量，下方賦值原理為：arr[j+1]--->temp;arr[j]--->arr[j+1];temp--->arr[j]
         var temp=arr[j+1];
         arr[j+1]=arr[j];
         arr[j]=temp;
       }
     }
   }

比較過程

第一輪

第1次比較：5 6 4 3 2 1

第2次比較：5 4 6 3 2 1

第3次比較：5 4 3 6 2 1

第4次比較：5 4 3 2 6 1

第5次比較：5 4 3 2 1 6

第二輪 （第一輪結束最后一位最大的數6不再比較）

第1次比較：4 5 3 2 1

第2次比較：4 3 5 2 1

第3次比較：4 3 2 5 1

第3次比較：4 3 2 1 5

第三輪 （第二輪結束最后一位最大的數5不再比較）

第1次比較：3 4 2 1

第2次比較：3 2 4 1

第3次比較：3 2 1 4

第四輪 （第三輪結束最后一位最大的數4不再比較）

第1次比較：2 3 1

第2次比較：2 1 3

第五輪 （第四輪結束最后一位最大的數3不再比較）

第1次比較： 1 2

泡排序是一個很經典的面試題，每次排序都能將最大的數字排到最后，或者將最小的數字排到最前面。現在有一個問題如下：

1、問題

如果要對下面這一組數據從小到大進行排列，你肯定會說，我直接一看就能看出來，一分鐘就能排出順序來。

[75,66,33,34,31,337,65,346]

那是因為這里的數字只有8個，如果有800個呢？

所以我們得靠計算機，得用算法。

為了方便起見，我們就把這8個數字想象成800個，原理是一樣的，先看看冒泡排序是怎樣的思想吧。

2、冒泡排序思想

• 基本思想: 冒泡排序，類似于水中冒泡，較大的數沉下去，較小的數慢慢冒起來，假設從小到大，即為較大的數慢慢往后排，較小的數慢慢往前排。
• 直觀表達，每一趟遍歷，將一個最大的數移到序列末尾。

結論：每次循環從起始位置 n 與 n+1 進行對比，符合條件就互相調換。

3、基本原理

從后往前（或從前往后）兩兩比較相鄰元素的值，若為逆序，則交換它們，直到序列比較完。稱這樣過程為一趟冒泡排序，最多只需n-1趟排序。 每一趟排序都可以使一個元素移動到最終位置，已經確定最終位置的元素在之后的處理中無需再對比。 如果某一趟排序過程中未發生“交換”，則算法可提前結束。

4、排序算法

冒泡排序流程圖：

4.1、javascript實現代碼

<script type="text/javascript">
 function maopao(array){
     var temp;
     for(var i=0;i<array.length;i++){ //比較多少趟，從第一趟開始
        for(var j=0;j<array.length-i-1;j++){ //每一趟比較多少次數
           if(array[j]>arra[j+1]){
              temp=array[j];
              array[j]=array[j+1];
              array[j+1]=temp;
           }
        }
     };
     return array;
 }

 var numbers=[65,4,43,37,31,17,6,46];
 var s=maopao(numbers);
 console.log(s);
</script>

4.2、java實現代碼

java冒泡排序跟javascript冒泡排序肯定原理是相同的，不同的就是語言不同，下面就來實現java的冒泡排序。

    public static void main(String[] args) {
         int[] arr = {3,2,3,4,5};
        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, j+1);
                }
            }
        }
    }

在面試時能寫出以上代碼，基本沒啥問題了，但是還有種最優的選擇就是使用遞歸方式，把下面方式寫出來，面試官會對你刮目相看的。

優化冒泡排序并測試其最好時間復雜度

冒泡排序通過循環將數組中相鄰的兩個值進行對比、交換已到達排序的目的。那么，對于相同長度的已排序數組和未排序數組來說，它們所消耗的時間是一樣的。

5、使用遞歸優化冒泡排序

冒泡排序方法（下面方法默認使用從小到大有序排列的數組）

  public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            long start = System.currentTimeMillis();
            /*
            通過遞歸來逐一判斷是否有 arr[n] > arr[n+1] 或者 arr[n] > arr[n+1]的情況
                1.當數組為有序時，最快時間復雜度為n
                2,當數組完全無序時，時間復雜度會比普通的冒泡排序高
            */
            boolean flag = recursion(arr,i);
            long end = System.currentTimeMillis();
            System.out.println("遞歸所用時間："+(end-start));
             // 如果flag==true，則數組是有序的，直接結束排序方法
            if (flag) break;    
            for (int j = 0; j <arr.length-1-i; j++) {
                if (arr[j] > arr[j+1]) {
                    temp(arr, j, j+1);
                }
            }
        }
    }
    // 打印
    public static void print_b(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if( i == arr.length-1 ) System.out.print(arr[i]);
            else System.out.print(arr[i] + ",");
        }        
        System.out.println("]");
    }
    // 交換
    public static void temp(int[] arr , int num1,int num2) {
        int temp  = arr[num1];
        arr[num1] = arr[num2];
        arr[num2] = temp;
    }

遞歸方法

1. 調用方法傳遞數組arr和當前數組下標n；
2. 通過遞歸對下標為n的值和下標為n+1 的值對比。

• 當 n == arr.length-1，即n已經到達數組最后一個值的下標時，返回true；
• 當存在 arr[n] > arr[n+1] 時返回 false 并結束方法。

 // 遞歸
    public static boolean recursion(int[] arr,int n ) {
        if (n == arr.length-1) {
            return true;
        }else if (arr[n] > arr[n+1] ) {
            return false;
        }
        return recursion(arr, n+1);
    }

小結

1.冒泡排序一般是通過兩層循環進行處理，第一層循環主要為了讓冒泡排序成功，數組需要進行多少次大循環，這里我們確定了在一個大于等于兩個數字的數組時（因為只存在一個數字的數組不需要排序），確定一個數字的排序就需要一個大循環，即n個數字有n-1次大循環；第二層循環主要是將數組的第一個數字與其后面的數字進行比較，然后確定排序。

2.綜上所述，在第二層循環完成的時候，第一層大循環也完成了一次，因此該數組就已經確定好了一個數字的排序在所有循環完成后，冒泡排序（數字從小到大）就完成了。

3.說白了就是1和2比，把大的放后面，2和3比，一樣，大的放后面，3和4比，直到比完一圈，這樣的話，最大的永遠被放后面，于是就排了最后一個了，把前面的n-1個再來一遍，于是又有一個最大值，再來，最后排完了。

4.冒泡排序由于比較簡單和容易理解，往往會成為面試時首先想到的排序算法問題。小伙伴如果能手寫出來，完全不怕面試啦。