js5种排序算法

1. 插入排序 时间复杂度 O(n^2)
算法描述：
1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤 3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤 2~5
编程思路：
双层循环，外循环控制未排序的元素，内循环控制已排序的元素，将未排序元素设为标杆，与已排序的元素进行比较，小于则交换位置，大于则位置不动

    let arr = [5, 6, 3, 1, 8, 7, 2, 4]
    for (let i = 1; i < arr.length; i++) {
      let tmp = arr[i]
      for (let j = i; j >= 0; j--) {
        if (tmp < arr[j - 1]) {
          arr[j] = arr[j - 1]
        } else {
          arr[j] = tmp
          break
        }
      }
    }

2.选择排序 时间复杂度 O(n^2)
算法描述：直接从待排序数组中选择一个最小（或最大）数字，放入新数组中。
编程思路：先假设第一个元素为最小的，然后通过循环找出最小元素，然后同第一个元素交换，接着假设第二个元素，重复上述操作即可。

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

3.归并排序 时间复杂度 O(nlogn)
算法描述：
1.假设待排序数组的长度为n。首先将数组分成两个长度为n/2的数组
2.重复步骤1，直至拆分后的数组长度为1，可以认为原数组最终拆分成了n个有序的长度为1的数组（以上可以理解为从上往下生成一个二叉树的过程）
3.从下往上，分别将二叉树节点的两个子元素数组进行两两合并，最终得到一个有序的长度为n的数组
编程思路：将数组一直等分，然后合并。

    function merge(left, right) {
      var tmp = []
      while (left.length && right.length) {
        if (left[0] < right[0]) {
          tmp.push(left.shift())
        } else {
          tmp.push(right.shift())
        }
      }
      return tmp.concat(left, right)
    }
    function mergeSort(arr) {
      if (arr.length === 1) return arr
      var mid = Math.floor(arr.length / 2), left = arr.slice(0, mid), right = arr.slice(mid)
      return merge(mergeSort(left), mergeSort(right))
    }

4.快速排序 时间复杂度 O(nlogn)
算法描述：
1.在数据集之中，选择一个元素作为”基准”（pivot）。
2.所有小于”基准”的元素，都移到”基准”的左边；所有大于”基准”的元素，都移到”基准”的右边。这个操作称为分区 (partition)操作，分区操作结束后，基准元素所处的位置就是最终排序后它的位置。
3.对”基准”左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。
这里用了阮一峰的快速排序，网上似乎有争议，不过我觉得不错。

    function quickSort(arr) {
        if (arr.length <= 1) {
          return arr
        }
        var pivotIndex = Math.floor(arr.length / 2)
        var pivot = arr[pivotIndex]
        var left = arr.filter(e => {
            return e < pivot
        })
        var right = arr.filter(e => {
            return e > pivot
        })
        return quickSort(left).concat([pivot], quickSort(right))
      }

5.冒泡排序 时间复杂度 O(n^2)
算法描述：
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
编程思路：外循环控制需要比较的元素，比如第一次排序后，最后一个元素就不需要比较了，内循环则负责两两元素比较，将元素放到正确位置上

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