算法：1冒泡排序

let arr = [5,2,3,6,4,1]
function bubbleSort(arr){
    for(let i = 0;i<arr.length-1;i++){
        for(let j = 0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                let temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}
bubbleSort(arr)
console.log(arr)

let arr = [5,2,3,6,4,1]
function bubbleSort(arr){
    for(let i = 0;i<arr.length-1;i++){
        for(let j = 0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                let temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;//这一点不同
}
bubbleSort(arr)
console.log(arr)

上面两块代码，第二个是我先接触的，当时没有调用，输出arr后，还是原来的arr。

然后去找问题出现在哪？当时怀疑是return的原因，现在用实验的方法，测试后，最后的结果是：因为没有调用。

我是这样实验的。return是条件1   调用是条件2  

然后设计为4个情况，有1有2，有1没2，有2没1，没2 没1；

最后结果   为：true false true false

然后发现  调用时必须的，return是可有可无的（存疑）；

因为基础差，对于这些基础的知识点，就不是根深蒂固在脑子里，需要去验证一下，也对自己有所怀疑。

return是在函数中返回一个值。如果按照这个这个函数来说，运行的结果和return的结果是一样的，这应该就是return可有可无的原因吧。   

最开始，没有想到去调用这个函数，是因为不自信，想到了这一点，但对自己学的不扎实深感惭愧，就没有沿着这个思路思考。

这个排序是有优化的。设定一个flag=true；当前一个值大于后一个值时。让他flase，如果这个循环里没有前一个大于后一个的情况了，也就是flag为true了，就break。跳出循环。

下边抄两个代码比较一下。

没有优化的。

// 冒泡排序 从小到大排序
    var arr = [1, 2, 3, 5, 7, 4, 8, 9, 10];
    var t = 0;
    var c = 0;

    for (var i = 0; i < arr.length - 1; i++) {
        t++;
        for (var j = 0; j < arr.length - 1 - i; j++) {
            c++;
            if (arr[j] > arr[j + 1]) {
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    console.log(arr);  // [1, 2, 3, 4, 5, 7, 8, 9, 10]
    console.log("外层循环了" + t + "趟," + "内层循环了" + c + "次");  // 外层循环了8趟,内层循环了36次

优化后的

// 冒泡排序 从小到大排序
     var arr = [1, 2, 3, 5, 7, 4, 8, 9, 10];
     var flag = true;
     var t = 0;
     var c = 0;

     for (var i = 0; i < arr.length - 1; i++) {
         flag = true;
         t++;
         for (var j = 0; j < arr.length - 1 - i; j++) {
             c++;
             if (arr[j] > arr[j + 1]) {
                 var temp = arr[j];
                 arr[j] = arr[j + 1];
                 arr[j + 1] = temp;
                 flag = false;
             }
         }
         if (flag) {
             break;
         }
     }

     console.log(arr);  // [1, 2, 3, 4, 5, 7, 8, 9, 10]
     console.log("外层循环了" + t + "趟," + "内层循环了" + c + "次"); // 外层循环了3趟,内层循环了21次

这里贴上，原作者【CSDN博主「Relife-li」】的解释：

解释一下： 先假设一个flag为true，在最外层循环开始时设置 flag = true; ，然后进入内层的循环，只要是前一个数大于后一个数，就会执行换位的代码，就设置 flag = false;，等于说只要内层循环有进行过大小数换位操作flag就会被设置为false；内层循环结束后，代码就执行到 if( flag ){ break; } 的这一步，因为内层循环将flag设置为false了，break; 并不会执行；最外层循环会继续下一次循环，然后再一次内层循环并执行大小数的排序操作，重复以上所说的逻辑…..直到内层循环没有满足 arr[j] > arr[j + 1] 条件的数了（这个时候排序已经好了），break； 执行，直接跳出循环，目的达到； 呃呃，语言解释不怎么直接，还是上代码吧~

希望对大家有帮助。