排序算法之归并排序

排序算法之归并排序

---

1. 常见排序算法的时间复杂度：

• 时间复杂度为 O(N ^ 2) 的有：选择排序、冒泡排序、插入排序
• 时间复杂度为 O(N * log N) 的有：归并排序、快速排序
• 时间复杂度为O(N * log N)的算法比时间复杂度为 O(N ^ 2)的算法好的多
• 时间复杂度就相当于数组的长度N与执行时间的关系
• 时间复杂度的表示，按算最坏的情况看，而且忽略常数时间(执行时间确定的时间)
• 算法的时间复杂度表示相同，它的区别是常数时间不同，但要排序的数组长度很长时，常数时间的影响可以忽略不计

2. 归并排序

排序思路：

1. 整体是递归，不断对数组二分，基准条件是数组只剩一个元素自然有序，左边排好序+右边排好序+merge让整体有序
2. 整体有序过程利用双指针分别指向左右边数组，按条件将最小值依次加入到辅助数组中，再将辅助数组整合到原数组中
3. 当然也可以利用非递归思路去实现，因为所有的递归方法都可以转为非递归方法

3. 代码实现(JavaScript)

• 递归实现(思路简单)：

  // 归并排序
  function mergeSort1(arr) {
    // 对参数进行判断
    if (!Array.isArray(arr) || arr.length < 2) {
      return arr
    }
    // 排序过程的方法
    process(arr, 0, arr.length - 1)
    // 返回排序后的arr
    return arr
  }
  
  // 对数组指定范围内的元素进行归并排序
  function process(arr, L, R) {
    // 基准条件
    if (L === R) return
  
    // 取范围中点，相当于 Math.floor((R + L) / 2)，优点在 位运算更快，可避免数字溢出
    let mid = L + ((R - L) >> 1)
    // 不断递归拆分
    process(arr, L, mid)
    process(arr, mid + 1, R)
    // 对数组拆分后范围的元素进行排序合并的方法
    merge(arr, L, mid, R)
  }
  
  // 对数组范围内的元素进行排序合并
  function merge(arr, L, M, R) {
    // 辅助数组
    let help = []
    let i = 0 // help数组的索引
    let p1 = L // 指针1，针对左边数组
    let p2 = M + 1 // 指针2，针对右边数组
  
    // 当左边或右边数组都没有越界时，将最小值依次加入help
    while (p1 <= M && p2 <= R) {
      help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++]
    }
    // 当一个数组越界时，另一个数组可能还有元素，直接加到help后
    while (p1 <= M) {
      // 左边数组还有元素的话
      help[i++] = arr[p1++]
    }
    while (p2 <= R) {
      // 右边数组还有元素的话
      help[i++] = arr[p2++]
    }
  
    // 最后将help数组，覆盖到arr上
    for (let i = 0; i < help.length; i++) {
      arr[L + i] = help[i]
    }
  }
  
  

• 循环迭代实现：

  • 循环迭代实现与递归的思路有所不同，递归是从大范围不断二分到满足基准条件，再不断合并结果；而循环迭代是从最小条件范围开始，使数组在此条件范围下依次有序，并进行结果合并排序，条件范围不断翻倍，直到超出边界条件。如：

    [2,8,6,9,3,7,4] (条件范围为1，1对1排序 连续2个有序) => [2,8, 6,9, 3,7,4]

    [2,8, 6,9, 3,7, 4] (条件范围为2，2对2排序 连续4个有序) => [2,6,8,9, 3,4,7]

    [2,8, 6,9, 3,7, 4] (条件范围为4，4对4排序 连续8个有序) => [2,3,4,6,7,8,9]

  • 代码：

    function mergeSort2(arr) {
      // 对参数进行判断
      if (!Array.isArray(arr) || arr.length < 2) {
        return arr
      }
    
      let N = arr.length // 数组长度
      let mergeSize = 1 // 条件范围，会不断翻倍
    
      // 条件范围大于数组长度时结束循环
      while (mergeSize < N) {
        let L = 0 // 条件范围的左端
        // 使数组在此条件范围下依次有序
        while (L < N) {
          let M = L + mergeSize - 1 // 条件范围的中间
          if (M >= N) break // 当数组剩余此次没排序的值小于范围规定的值
          let R = Math.min(M + mergeSize, N - 1) // 条件范围的右端
          // 对数组范围内的元素进行排序合并的方法，与递归实现用的是一致的
          merge(arr, L, M, R)
          L = R + 1 // L的值跳到下一次将要排序的开始
        }
        // 提前判断mergeSize与N的关系，避免*2时数字过大时溢出
        if (mergeSize > N / 2) break 
        mergeSize *= 2 // 条件范围翻倍
      }
      return arr // 返回排序好的结果
    }