js排序

1.array.sort(fun)；参数fun可选。规定排序顺序。必须是函数。
注：如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。
如果想按照其他规则进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b，其返回值如下：
若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
若 a 等于b，则返回 0。
若 a 大于 b，则返回一个大于 0 的值。
简单点就是：比较函数两个参数a和b，返回a-b 升序，返回b-a 降序
//注：原数组发生改变

var arr = [20, 60, 10, 8, 5, 90, 24];
    arr.sort(function(a, b) {
        return a - b; //升序    //[5, 8, 10, 20, 24, 60, 90]
        return b - a; //降序    //[90, 60, 24, 20, 10, 8, 5]
    });
    console.log(arr);
    var arr1 = [{id: 1, age: 10},{id: 2,age: 30}, {id: 4,age: 8}, {id: 3,age: 40}, {id: 5,age: 12}, {id: 6,age: 80}];
    arr1.sort(function(a, b) {
        if (a.id === b.id) { //升序
            return a.age - b.age //如果id相同，照年龄排序
        } else {
            return a.id - b.id
        }
    });
    console.log(arr1) // [{id: 1, age: 10},{id: 2, age: 30},{id: 3, age: 40},{id: 4, age: 8},{id: 5, age: 12},{id: 6, age: 80}]

2.array.reverse()//此方法为倒序，也就是反过来。并不会进行大小排序

var arr = [20, 60, 10, 8, 5, 90, 24];
arr.reverse();
console.log(arr); //[24, 90, 5, 8, 10, 60, 20]

3.冒泡排序 //冒泡排序的思想就是从左到右依次比较数组a相邻的两个数，将较大的数放到后面，一轮比较之后，最大的数会排到最后面；第二轮比较后次大的数会在倒数第二的位置，直到进行a.length次比较后，数组就会升序排列。

function bubbleSort(arr) {
    arr.map((v, i) => {
        arr.slice(0, arr.length - i).map((v, j) => {
            if (v < arr[j - 1]) {
                arr[j] = arr[j - 1]
                arr[j - 1] = v
            }
        })
    })
    return arr
}
bubbleSort([2, 4, 1, 7, 3, 5]) //[1, 2, 3, 4, 5, 7]

4.选择排序 //选择排序的思想是每次从数组中选出一个最小数放到数组最前面，第二次选择剩余数里最大的放到数组第二位，直到所有的数都被选择完
//选择排序——每次选择出最小的数，排到最前面

  function selectSort(arr) {
      arr.map((v, i) => {
        let minIndex = i;
        arr.slice(i).map((m, j) => {
          minIndex = m < arr[minIndex] ? j + i : minIndex;
        });
        if (minIndex !== i) {
          arr[i] = arr[minIndex];
          arr[minIndex] = v;
        }
      });
      return arr;
    }
    selectSort([2, 4, 1, 7, 3, 5]); //[1, 2, 3, 4, 5, 7]

//选择排序——每次选择出最大的数，排到最后面

  function selectSort(arr) {
      arr.map((v, i) => {
        let maxIndex = 0,
          lastIndex = arr.length - i - 1;
        arr.slice(0, arr.length - i).map((m, j) => {
          maxIndex = m > arr[maxIndex] ? j : maxIndex;
        });
        if (maxIndex !== lastIndex) {
          let lastNum = arr[lastIndex];
          arr[lastIndex] = arr[maxIndex];
          arr[maxIndex] = lastNum;
        }
      });
      return arr;
    }
    selectSort([2, 4, 1, 7, 3, 5]); //[1, 2, 3, 4, 5, 7]

5.快速排序 // 快速排序的思想是选定一个数为基准，小于这个基准的数放到左边，大于或等于基准的数放右边；然后对左边和右边的数分别进行快速排序，最后合并左边、基准和右边即可。

function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    } else {
        let left = [],
            right = [];
        arr.slice(1).map((v, i) => {
            if (v <= arr[0]) {
                left.push(v);
            } else {
                right.push(v);
            }
        });
        return quickSort(left).concat(arr[0], quickSort(right));
    }
}
quickSort([2, 4, 1, 7, 3, 5]); //[1, 2, 3, 4, 5, 7]

6.插入排序 //插入排序的思想是依次取出原数组中的一个数插入到一个有序数组中正确的位置，直到原数组里的数都被取完放入新数组，这里需要用到一个新的数组。

function insertSort(arr) {
        let newArr = [];
        arr.map((v, i) => {
            if (i === 0) {
                newArr.push(v);
            } else {
                let flag = newArr.some((m, j) => {
                    if (m > v) {
                        //将v插入m前
                        newArr.splice(j, 0, v);
                        return true;
                    }
                });
                if (!flag) newArr.push(v);
            }
        });
        return newArr;
    }
    insertSort([2, 4, 1, 7, 3, 5]); //[1, 2, 3, 4, 5, 7]