js排序方式

1.sort

sort是数组的一个方法，sort() 方法用于对数组的元素进行排序！然后返回排序后的数组。默认排序顺序是升序，建立在将元素转换为字符串，然后比较其UTF-16代码单元值的序列的基础上，请注意，该数组按位置排序，并且不进行任何复制！

var arr = [5,6,10,7]
    //无参数 
    var arr1 = arr.sort()
    console.log(arr1) // [10,5,6,7]
    //带参数
    var arr2 = arr.sort((a,b) => {
        return a-b
    })
    console.log(arr2) // [5,6,7,10]

2.冒泡排序

1. 比较所有相邻元素,如果第一个比第二个大，则交换它们
2. 一轮下来保证可以找到一个数是最大的
3. 执行n-1轮，就可以完成排序

 

//冒泡排序
    var arr = [5,6,10,7]
    function bubbleSort(array) {
      const len = array.length
      if (len < 2) return array
      for (let i = 0; i < len; i++) {
        for (let j = 0; j < i; j++) {
          if (array[j] > array[i]) {
            const temp = array[j]
            array[j] = array[i]
            array[i] = temp
          }
        }
      }
      return array
    }
    bubbleSort(arr);  // [5,6,7,10]

3.选择排序

1. 找到数组中的最小值，选中它并将其放置在第一位
2. 接着找到第二个最小值，选中它并将其放置到第二位
3. 执行n-1轮，就可以完成排序

//选择排序
    var arr = [5,6,10,7]
    function selectSort(array) {
      const len = array.length
      let temp
      let minIndex
      for (let i = 0; i < len - 1; i++) {
        minIndex = i
        for (let j = i + 1; j < len; j++) {
          if (array[j] <= array[minIndex]) {
            minIndex = j
          }
        }
        temp = array[i]
        array[i] = array[minIndex]
        array[minIndex] = temp
      }
      return array
    }
    selectSort(arr); // [5,6,7,10]

 4.插入排序

1. 从第二个数开始往前比
2. 比它大就往后排
3. 以此类推进行到最后一个数

    //插入排序
    var arr = [5,6,10,7]
    function insertSort(array) {
      const len = array.length
      let current
      let prev
      for (let i = 1; i < len; i++) {
        current = array[i]
        prev = i - 1
        while (prev >= 0 && array[prev] > current) {
          array[prev + 1] = array[prev]
          prev--
        }
        array[prev + 1] = current
      }
      return array
    }
    
    insertSort(arr); // [5,6,7,10]

 5.快速排序

分区: 从数组中任意选择一个基准，所有比基准小的元素放到基准前面，比基准大的元素放到基准的后面
递归：递归地对基准前后的子数组进行分区

   //快速排序
    var arr = [5,6,10,7]
    function bubble(arr){
      if (arr.length < 2) {
        return arr;
      }
      let left = [];
      let right = [];
      let numIndex = Math.floor(arr.length / 2);
      let num = arr.splice(numIndex, 1);
      arr.forEach((item) => {
        if (item < num) {
          left.push(item);
        } else if (item > num) {
          right.push(item);
        }
      });
      return bubble(left).concat(num, bubble(right));
    };
    console.log(bubble(arr)); // [5,6,7,10]

 6.归并排序

分: 把数组劈成两半，再递归地对数组进行“分”操作，直到分成一个个单独的数
合：把两个数合并为有序数组，再对有序数组进行合并，直到全部子数组合并为一个完整数组

    //归并排序
    var arr = [5,6,10,7]
    function fn(arr) {
      function sort(left, right) {
        let i = 0;
        let j = 0;
        let result = [];
    
        while (left[i] && right[j]) {
          if (left[i] < right[j]) {
            result.push(left[i++]);
          } else {
            result.push(right[j++]);
          }
        }
    
        while (left[i]) {
          result.push(left[i++]);
        }
    
        while (right[j]) {
          result.push(right[j++]);
        }
    
        return result;
      }
  
      function fen(arr) {
        if (arr.length < 2) return arr;
        let midIndex = Math.floor(arr.length / 2);
        let left = arr.slice(0, midIndex);
        let right = arr.slice(midIndex, arr.length);
        return sort(fen(left), fen(right));
      }
  
      return fen(arr);
    }
    console.log(fn(arr)); // [5,6,7,10]