【笔记】JavaScript版数据结构与算法——基础算法之“排序类”（164. 最大间距）

---

最大间距

1.题目

164. 最大间距 - 力扣（LeetCode）

给定一个无序的数组，找出数组在排序之后，相邻元素之间最大的差值。
如果数组元素个数小于 2，则返回 0。

示例 1

输入: [3,6,9,1]
输出: 3
解释: 排序后的数组是 [1,3,6,9], 其中相邻元素 (3,6) 和 (6,9) 之间都存在最大差值 3。

示例 2

输入: [10]
输出: 0
解释: 数组元素个数小于 2，因此返回 0。

说明:

• 你可以假设数组中所有元素都是非负整数，且数值在 32 位有符号整数范围内。
• 请尝试在线性时间复杂度和空间复杂度的条件下解决此问题。

题目模板

/**
 * @param {number[]} nums
 * @return {number}
 */
var maximumGap = function(nums) {

};

2.思路分析

传统方法：先排序，再遍历一遍，遍历过程中找到最大差值
升级后：在排序过程中找到最大差值

3.所用到的方法

见题解

4.题解及优化

传统方法：

let maximumGap = (nums) => {
  let maxGap = 0
  if (nums.length < 2) return maxGap
  // 排序
  for (let i = nums.length - 1; i > 0; i--) {
    for (let j = 0; j < i; j++) {
      [nums[j], nums[j + 1]] = nums[j] > nums[j + 1] ? [nums[j + 1], nums[j]] : [nums[j], nums[j + 1]]
    }
  }
  nums.reduce((pre, cur) => {
    maxGap = cur - pre > maxGap ? cur - pre : maxGap
    return cur
  })
  return maxGap
}

---

在排序过程中缓存最大间距：

  let maxGap = 0
  if (nums.length < 2) return maxGap
  if (nums.length === 2) return nums[1] - nums[0] > maxGap ? nums[1] - nums[0] : maxGap
  // 排序
  for (let i = nums.length - 1; i > 0; i--) {
    for (let j = 0; j < i; j++) {
      [nums[j], nums[j + 1]] = nums[j] > nums[j + 1] ? [nums[j + 1], nums[j]] : [nums[j], nums[j + 1]]
    }
    if (i < nums.length - 1) maxGap = nums[i + 1] - nums[i] > maxGap ? nums[i + 1] - nums[i] : maxGap
  }
  return maxGap

结果并不如意

---

使用基数排序

let maximumGap = (nums) => {
  let maxGap = 0
  if (nums.length < 2) return maxGap

  let mod = 10 // 进制/基数，常见还有以radix为变量名
  let dev = 1 // 用来取进制位数据
  let maxDigit = Math.max(...nums).toString().length // 最大位数
  let counter = []
  for (let i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
    for (let j = 0; j < nums.length; j++) {
      // 提取相应进制位的数据（个位/十位/百位...），相当于桶排序的桶的编号
      let bucket = Math.floor((nums[j] % mod) / dev)
      // 初始化统计数组
      if (counter[bucket] == null) {
        counter[bucket] = []
      }
      // 对应入组（这步相当于排序），利用LSD(次位优先)进行基数排序
      counter[bucket].push(nums[j])
    }
    let pos = 0
    for (let j = 0; j < counter.length; j++) {
      let value = null
      if (counter[j] != null) {
        while ((value = counter[j].shift()) != null) {
          nums[pos++] = value
        }
      }
    }
    // console.log('nums', nums) // 这里可以得到按个位、十位...排序结果
  }
  nums.reduce((pre, cur) => {
    maxGap = cur - pre > maxGap ? cur - pre : maxGap
    return cur
  })
  return maxGap
}

还不错

---

结合桶排序和鸽笼原理：

let maximumGap = (nums) => {
  if (nums.length < 2) return 0
  let min = Math.min(...nums) // 最小值
  let max = Math.max(...nums) // 最大值
  if (max - min === 0) return 0
  let gap = Math.ceil((max - min) / (nums.length - 1)) // 均差（两两差值的平均值向下取整）
  // 桶（区间）下限、桶（区间）上限（填充的目的是跳过空桶（区间））
  let bucketsMin = new Array(nums.length - 1).fill(max) // Number.MAX_SAFE_INTEGER
  let bucketsMax = new Array(nums.length - 1).fill(min)
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] === min || nums[i] === max) continue // 桶中不容纳最大最小两个值
    let idx = Math.floor((nums[i] - min) / gap) // 定位正确的桶
    // 核心步骤：统计过程中只留下桶（区间）上下限，去掉其他无关中间元素（最大间距一定是大于均差的，一定产生在边缘值之差之间）
    bucketsMin[idx] = Math.min(nums[i], bucketsMin[idx]) // 统计桶（区间）下限
    bucketsMax[idx] = Math.max(nums[i], bucketsMax[idx]) // 统计桶（区间）上限
  }
  let maxGap = 0 // 存储最大间隔
  let pre = min
  for (let i = 0; i < nums.length - 1; i++) {
    if (bucketsMax[i] === min) continue // 跳过空桶（区间）
    // 核心步骤：统计边缘值之差的最大值（还有一步在循环外）
    maxGap = Math.max(maxGap, bucketsMin[i] - pre) // 本区间下限 与 上一个区间（空区间略过）上限 差值 的 最大值（第一个区间下限与最小值差值也在比较之中）
    pre = bucketsMax[i]
  }
  maxGap = Math.max(maxGap, max - pre) // 最后非空一个区间下限与最大值差值也参与比较
  return maxGap
}

鸽笼原理也称抽屉原理：n 个物品放入 m 个容器中，如果 n > m 那么一定有一个容器装有至少两个物品。同理n个桶，放m个物体，如果 n > m 那么一定有一个容器是空桶。

假设对于数组中的任意一个元素都有一个桶，那么每个元素恰好占据一个桶。现在增加桶的个数，必然会有至少一个桶是空桶，那么这个空桶附近的两个元素之差就是我们想要的结果

代码中将两个最值放到最两边的桶内，剩下 数组元素个数-1 个桶，在元素入桶过程中不免会有，多个元素入一个桶的情况发生，因此桶内只放属于这个桶的最大值和最小值（区间上下限），然后寻找空桶的过程就是：

• 本区间下限 与 上一个区间（空区间略过）上限 差值 的 最大值
• 第一个区间下限与最小值差值也在比较之中
• 最后非空一个区间下限与最大值差值也参与比较

可以这样理解：最大间隔一定是大于平均间隔的（$(max-min)/(n-1)$），而平均间隔就是桶的容量。

图片来自：LeetCode-164.MaximumGap(最大间距)
———————————