简单说说冒泡排序的优化

跟着逆战班老师学习，整理了一下冒泡排序程序更优化一些
思路：将数组中的相邻的两个数值进行比较，若后面的数值大于前面的数值，那么这两个数值交换位置，否则不与调换。
以数组[5,4,3,2,1]为例说明一下，

我们定义外层循环次数为j，内部循环次数为i；我们知道数组的索引下标都是从0开始的，所以我们将j与i的初始值也定为0，从0 取值也是为了方便数组内部从arr[0]开始取值进行比较。

j=0 外层的循环第一次循环：

起使数组：5，4，3，2，1
i=0 内部循环第一次比较：4，5，3，2，1
i=1 内部循环第二次比较：4，3，5，2，1
i=2 内部循环第三次比较：4，3，2，5，1
i=3 内部循环第四次比较：4，3，2，1，5

j=1 外层的循环第二次循环：

起使数组：4，3，2，1，5 ----->也就是上一次外部循环结束后的数组
i=0 内部循环第一次比较：3，4，2，1，5
i=1 内部循环第二次比较：3，2，4，1，5
i=2 内部循环第三次比较：3，2，1，4，5 -----> 此时4与1比较完毕之后，4和5没有必要在执行程序进行比较了

j=2 外层的循环第三次循环：

起使数组：3，2，1，4，5 ----->也就是上一次外部循环结束后的数组
i=0 内部循环第一次比较：2，3，1，4，5
i=1 内部循环第二次比较：2，1，3，4，5 ----->此时3与1比较完毕之后，3与4、4和5没有必要在执行程序进行比较了

j=3外层的循环第四次循环：

起使数组：2，1，3，4，5 ----->也就是上一次外部循环结束后的数组
i=0 内部循环第一次比较：1，2，3，4，5 ----->此时2与1比较完之后，2与3、3与4、4和5没有必要在执行程序进行比较了

 同时外层没有必要在执行一次循环进行1与2的比较了，这样便优化了程序执行的次数。

我们分析一下规律：
整个数组的长度：arr.length=5;
数组内部数值的索引下标为：arr.length-1=4
我们找到这样的规律：外层循环次数最多为 j =(arr.length - 1) - 1 ；内层循环次数最多为 i = (arr.length - 1 ) - 1 - j ；
【注意这里次数取值是0~3】

var arr = [5,4,3,2,1];
        // 外层循环,外层循环次数最多为j=(arr.length-1)-1
        for(var j = 0 ; j <= (arr.length-1) -1 ; j++){
            // 上一次比较出的数值,不参与下一次循环 -j
            // 当次循环的最后一个单元,通过倒数第二个单元,参与比较不参与循环 -1
            for (var i = 0; i <= (arr.length-1) -1 - j ; i++) {
                if (arr[i] > arr[i + 1]) {
                    // 通过数据交换更改数据比较后的位置
                    var middle = 0;
                    middle = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = middle;
                }
            }
        }
        console.log(arr);

输入结果如图：