一、sort的原理及机制

数组自带的排序方法

arr.sort(function (a, b) {
    // 迭代数组中的每一项，每迭代一次，这个回调函数执行一次
    //   a:当前迭代这一项
    //   b:它的后一项
    // 返回一个“>0”的值，让a/b交换位置，否则位置不变
    // ----新版谷歌正好反着
    //   b:当前迭代这一项  a:它的后一项   返回"<0"的值让两者交换位置
    return a - b;
});
console.log(arr);

二、冒泡排序的原理及机制

原理

实现冒泡的三个办法

1.两个循环一个空变量

/*
 * 数组的冒泡排序：经典算法之一
 */
// arr:传递给函数要排序的数组
function bubbleSort(arr) {
    // 控制比较多少轮「每一轮都是把当前最大值放在末尾」
    for (var i = 0; i < arr.length - 1; i++) {
        //var一个变量等于false 
        var flag = false;
        // 控制每一轮比较多少次「从数组第一项开始，两两比较」
        for (var j = 0; j < arr.length - 1 - i; j++) {
            // 当前项大于后一项，则让两者交换位置
      //第一种写法：使用一个空变量来处理
            if (arr[j] > arr[j + 1]) {
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        // 如果当前这一轮，两两比较了一圈，都没有发现需要交换位置的，说明现在的数组就是排好序的，则直接结束循环即可，没必要再比较了
        if (!flag) break;
    }
    return arr;
}

2.两个循环不使用变量

function bubbleSort(arr) {
    // 控制比较多少轮「每一轮都是把当前最大值放在末尾」
    for (var i = 0; i < arr.length - 1; i++) {
        //var一个变量等于false 
        var flag = false;
        // 控制每一轮比较多少次「从数组第一项开始，两两比较」
        for (var j = 0; j < arr.length - 1 - i; j++) {
            // 当前项大于后一项，则让两者交换位置
      //第二种写法：不用变量
                arr[j] =arr[j] +arr[j + 1];
                arr[j + 1] = arr[j]-arr[j + 1];
                arr[j]=arr[j]-arr[j + 1]
         }       
        // 如果当前这一轮，两两比较了一圈，都没有发现需要交换位置的，说明现在的数组就是排好序的，则直接结束循环即可，没必要再比较了
        if (!flag) break;
    }
    return arr;
}

3.解构赋值

var ary = [100, 23, 5, 9, 33, 2]
for (var i = 0; i < ary.length - 1; i++) {
    var n = true;
    for (var j = 0; j < ary.length - 1 - i; j++) {
        if (ary[j] > ary[j + 1]) {
            [ary[j], ary[j + 1]] = [ary[j + 1], ary[j]];
            n = false;
        }
    }
    if (isNaN(n)) continue;
}
console.log(ary);

优化

优化只是把变量flag的初始值换成true，淼淼个人觉得，还是true比较好理解， 另外结构赋值也是真的很好用...

var arr=[8,16,134,25,1];
// 控制比较多少轮
for(var i=0;i<arr.length-1;i++){
    var flag=true;//假设已经排好序  true已经排好了
    for(var j=0;j<arr.length-1-i;j++){
      // 当前项如果大于后一项，则两者交换位置
        [ary[j],ary[j + 1]]=[ary[j + 1],ary[j]];   
      // 只要还发生一次交换位置，说明我们假设失败了，数组还没有排好序  false还没有排好
        flag=false;
        }
    }
  // 如果当前已经排好序了“flag===ture”，不需要在比较下一轮了
    if(flag) break;
}