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

每次對數組進行一次交換，只會確定最後的數，所以，下一次從頭開始比較，不需要再對最後一個數進行比較了，如果循環往復，直到最後只剩索引為0的數字，將不再需要進行循環比較。

舉個例子，有個數組如下：

[9, 7, 8, 33, 45]

第一次比較：

1. 9與7比較，交換位置；
2. 9再與8比較，交換位置；
3. 9與33比較，不需交換；
4. 33與45比較，不需交換；

第一次的結果為：

[7, 8, 9, 33, 45]

除了45確定為最大值外，其余項需要再一次的比較，直到最終後四項都確定了，不再需要再次比較。

下面展示了如何用js代碼實現冒泡排序：

方法一：

function bubblesort(arr, endindex) {
    var len = endindex ? endindex : arr.length;
    if(len == 1) {
        return arr;
    }
    for(var i=0; i< len - 1; i++) {
        
 
var prev = arr[i],
            next = arr[i+1];
        if(prev > next) {
            arr[i] = next;
            arr[i+1] = prev;
        }
    }
    arguments.callee(arr, len-1);
}

方法二

function bubblesort2(arr) {
    var len = arr.length, i = len, j = 0;
    while(i > 0) {
        for(j = 0; j< i - 1; j++) {
            
 
var prev = arr[j],
                next = arr[j+1];
            if(prev > next) {
                arr[j] = next;
                arr[j+1] = prev;
            }
        }
        i--;
    }
    return arr;
}

方法三（使用es6的解構賦值）：

export function bubblesort3(arr) {
    let len = arr.length;
    let [i, j] = [len, 0];
    while(i > 0) {
        for(j = 0; j< i - 1; j++) {
            let prev = arr[j],
                next = arr[j+1];
            if(prev > next) {
                [arr[j], arr[j+1]] = [next, prev];
            }
        }
        i--;
    }
    return arr;
}

排序-冒泡排序