冒泡排序是一个异常常见的排序算法，对于一个数组，每趟排序时依次对照两个相邻的数，若是他们的顺序错误就交流两数位置。以是，没趟排序都市排好一个数字，下一轮排序就可以少对照一个数字，直到只剩下一个数字，就所有排序好了。

举个例子，假设最终需要的效果是从小到大排列，对于数组：

[3, 5, 2, 6, 1, 7, 4]

之一趟排序的历程：

[3, 5, 2, 6, 1, 7, 4]

// 对照历程：
// 1. 对照 3 和 5，发现顺序准确，则稳固
[3, 5, 2, 6, 1, 7, 4]

// 2. 对照 5 和 2，发现顺序错误，交流位置
[3, 2, 5, 6, 1, 7, 4]

// 3. 对照 5 和 6，发现顺序准确，稳固
[3, 2, 5, 6, 1, 7, 4]

// 4. 对照 6 和 1，发现顺序错误，交流位置
[3, 2, 5, 1, 6, 7, 4]

// 5. 对照 6 和 7，发现顺序准确，稳固
[3, 2, 5, 1, 6, 7, 4]

// 5. 对照 7 和 4，发现顺序错误，交流位置
[3, 2, 5, 1, 6, 4, 7]

排序历程中，所有相邻数字对都对照了一遍，对照的历程中，实质上是对照的相邻位置，而不管位置上的数字是否在上一次对照中交流了位置，只管一个一个位置的对照下去，数字顺序错误就把数字位置交流。经由这趟排序，发现更大的数字 7 已经排到了最后一个位置，以是下一趟排序就不需要再对照最后一个位置的数字了。

第二趟排序历程：

// 经由之一趟排序后的数组
[3, 2, 5, 1, 6, 4, 7]

// 对照历程：
// 1. 对照 3 和 2，发现顺序错误，交流位置
[2, 3, 5, 1, 6, 4, 7]

// 2. 对照 3 和 5，发现顺序准确，稳固
[2, 3, 5, 1, 6, 4, 7]

// 3. 对照 5 和 1，发现顺序错误，交流位置
[2, 3, 1, 5, 6, 4, 7]

// 4. 对照 5 和 6，发现顺序准确，稳固
[2, 3, 1, 5, 6, 4, 7]

// 5. 对照 6 和 4，发现顺序错误，交流位置
[2, 3, 1, 5, 4, 6, 7]

// 最后一个数字不用对照

经由第二趟排序后，数字 6 也排到了准确的位置。第三趟排序时，最后两位数字都不用对照了。

每一趟排序，都市把剩余数字中更大的排到最后面。后面的排序历程就不再剖析了。清晰了排序历程，写代码来排序就很简朴了，代码如下：

function bubbleSort(arr) {
    var arr = arr.slice(0); // 保证排序后原数组稳固
    var len = arr.length;
    var tmp;

    // 只需要举行 len - 1 趟排序
    // 由于只剩下一个数字时不用再对照了
    for (var i = 0; i < len - 1; ++i) {

        // 每一趟都市排序好一个数字
        // 以是每趟只需排 len - i 个数字
        for (var j = 1; j < len - i; ++j) {

            // 若是右边的数比左边的小
            // 就交流位置
            if (arr[j] < arr[j-1]) {
                tmp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
            }
        }

        // 这里可以打印出每趟排序的效果
        // 以便考察排序历程
        // console.log(arr);
    }

    return arr;
}