根底排序算法

抉择排序

抉择一个基准值，通过遍历比出最小的和基准值替换
抉择一个基准索引，比方 0，而后让前面的值一次和这个 0 索引的值比拟，比他小（大）就两个值替换，比完一轮之后基准索引 +1。两轮循环，外层从 i = 0 开始，内层从 i + 1 开始.

  let arr = [12, 34, 30, 20, 4, 56]
  let targetIndex = 0

  for(let i = 1; i < arr.length; i++){for (let j = i; j < arr.length; j++) {if (arr[j] <= arr[targetIndex]) {let temp = arr[targetIndex]
              arr[targetIndex] = arr[j]
              arr[j] = temp
          }
      }
      targetIndex++
  } 
  console.log(arr)

冒泡排序

抉择从左或者从右开始比拟，从左抉择第一个值，一次和前面每一个值进行比拟，只有比它小的就替换地位，直到最初一个值为止。两轮循环，外层从 i = 0 开始，内层从 i + 1 开始

  let arr = [12, 34, 30, 20, 4, 56]

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

  console.log(arr)

插入排序

插入排序是把须要排序的数组分成两局部，第一局部是已排好的程序，默认从第一个值开始架设他已排好程序，前面这个第一局部的数组会越来越多，从小到大。每次拿新的目标值先和第一局部最大值进行比拟，比最大值大就地位不变进行下一个目标值，比最大值小就从大到小比过来地位后移一个直到插入到正确地位。外层循环从 1 开始 内层能够用 while 判断目标值和第一局部最大值的大小关系决定是否持续往前比拟，最初把目标值放到指定地位

  let arr = [12,13,11,4,34,454,21,22,421,42,44,55,2212]

  for (let i = 1; i < arr.length; i++) {
      let preIndex = i - 1
      let current = arr[i] // 数组的某一个值不是数组类型不存在援用
      while(preIndex >= 0 && current < arr[preIndex] ) {arr[preIndex + 1] = arr[preIndex]
          preIndex --
          console.log(current)
      }
      arr[preIndex + 1] = current
  }

疾速排序

1. 快排的原理如下。随机选取一个数组中的值作为基准值，从左至右取值与基准值比照大小。比基准值小的放数组右边，大的放左边，
2. 比照实现后将基准值和第一个比基准值大的值替换地位。而后将数组以基准值的地位分为两局部，持续递归以上操作。

须要递归，选两头值，有左右数组变量

    var quickSort = function(arr) {if (arr.length <= 1) {return arr;}
    var pivotIndex = Math.floor(arr.length / 2);
    var pivot = arr.splice(pivotIndex, 1)[0];
    var left = [];
    var right = [];

    for (var i = 0; i < arr.length; i++) {if (arr[i] < pivot) {left.push(arr[i]);
        } else {right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));
    };

归并排序

将数组分为两局部，再把两局部再分为两局部，晓得分为一个单元数组，在组合的时候两两进行有序组合 最初组合成有序数组

总结一下：

罕用排序办法

选冒快插归

1. 抉择和冒泡排序都是两层遍历，抉择比冒牌多了个基准值，基准值索引得累加。
2. 疾速排序是选一个两头值分成两个数组，返回 return quickSort(left).concat([pivot], quickSort(right))
3. 插入排序顾名思义就是插入，默认找出一个有序数组[index = 0], 而后拿前面的值和有序数组中的每个值比拟（从右往左，由大到小），找到了适合的地位就插入，用 for 嵌套一个 while 循环。插入的实质其实也是替换值有序数组增大一位