最大间距
- https://leetcode.cn/problems/maximum-gap/description/
描述
- 给定一个无序的数组 nums,返回 数组在排序之后,相邻元素之间最大的差值 。如果数组元素个数小于 2,则返回 0 。
- 您必须编写一个在「线性时间」内运行并使用「线性额外空间」的算法。
示例 1
输入: nums = [3,6,9,1]
输出: 3
解释: 排序后的数组是 [1,3,6,9], 其中相邻元素 (3,6) 和 (6,9) 之间都存在最大差值 3。
示例 2
输入: nums = [10]
输出: 0
解释: 数组元素个数小于 2,因此返回 0。
备注
- leetcode 的上的这一题,没有说明是整数的限定
- 如果在用例中新增了小数,会报错,比如:
xx.xx is not a valid value of type integer
提示
- 1 <= nums.length <= 10510^5105
- 0 <= nums[i] <= 10910^9109
Typescript 版算法实现
1 )借用原生sort + 迭代取相邻最大值
function maximumGap(nums: number[]): number {
// 如果数组长度小于2返回0
if (nums.length < 2) return 0;
// 排序 这个在 leetcode 上要传入回调,否则排序是乱序的
nums.sort((a, b) => a - b);
// 用它来保存相邻元素的最大差值
let max = 0;
for (let i = 1; i < nums.length; i++) max = Math.max(max, nums[i] - nums[i - 1]);
return max;
};
- 这个结果是对的,但是不符合题意
- 因为题目要求是线性的,一个原生sort的复杂度是 O(nlogn)
- 注意这个sort要传入回调
- 这个回调是和默认一致的从小到大,
- 不传回调,则在 leetcode 环境中debug发现获得的排序是乱的,无法通过
2 )基数排序来解
// 基数排序
function radixSort(list: number[]) {
const len = list.length; // 获取数组长度
const max = Math.max(...list); // 获取数组中最大值
let i = 0; // 用于计数的数组
let radix = 1; // 基数(个:1, 十:10, 百: 100, ...)
const tmp = new Array(len); // 临时倒腾数组
while(max >= radix) {
// 初始化存储桶 0 ~ 9, 全0填充
const bucket = new Array(10).fill(0);
// 对当前基数下的值进行累加计算总数
for(i=0; i<len; i++) {
// 获取当前基数下的值, 也就是对应的桶的下标
const currentRadixNum = Math.floor(list[i] / radix) % 10;
bucket[currentRadixNum] ++; // 从 0 开始自增, 这里桶中存储的是当前下标下对应数据的累计个数
}
// 计算当前数据位置: 基于桶内每个下标对应数据的累计个数,计算当前元素在整个桶中的位置,并反向赋值给当前桶
for(i = 1; i<10; i++) {
bucket[i] += bucket[i-1];
}
// 将a[i]的值按照桶存储的位置倒腾到临时数组tmp中
for(i = len-1; i>=0; i--) {
const currentRadixNum = Math.floor(list[i] / radix) % 10; // 当前基数下的数字
const currentIndex = bucket[currentRadixNum] - 1; // bucket存储的是位置,位置-1为下标
tmp[currentIndex] = list[i]; // 根据桶存储的位置,
bucket[currentRadixNum] --; // 桶内当前元素累计值 自减
}
// 再将临时数组中的元素倒腾回list中,此时完成了一轮的基于基数的处理
list.splice(0, len, ...tmp);
radix *= 10; // 基数进位处理
}
}
function maximumGap(nums: number[]): number {
// 如果数组长度小于2返回0
if (nums.length < 2) return 0;
radixSort(nums);
// 用它来保存相邻元素的最大差值
let max = 0;
for (let i = 1; i < nums.length; i++) max = Math.max(max, nums[i] - nums[i - 1]);
return max;
};
- 参考: https://blog.youkuaiyun.com/Tyro_java/article/details/134191965
- 虽然时间复杂度降下来了,满足题意,效率还行
3 )计数排序来解
function countSort(list:number[]) {
const len: number = list.length;
if (len < 2) return;
// 获取最大值和最小值
const max: number = Math.max(...list);
const min: number = Math.min(...list);
// 初始化计数数组
const countList: number[] = new Array(max - min + 1).fill(0);
// 初始化目标数组
const result: number[] = new Array(len);
// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
for(let i:number = 0; i < len; i++) countList[list[i] - min]++; // 遍历完成后计数数组就变成了累计数组
// 计算位置: 由上面的累计结果,计算累加后的位置, countList数组从累计数组,变成了位置数组
for(let j = 1; j < max - min + 1; j++) {
countList[j] += countList[j - 1];
}
// 根据累加后的位置, 将原数组中的数据按照位置进行分配,就得到排好序的数组,备注:数据可能重复,使用过的数据记得-1,从后向前遍历更好理解
for (let k:number = len - 1; k >= 0; k--) {
const currentIndex = countList[list[k] - min] - 1;
result[currentIndex] = list[k]; // 将原数组的当前元素整合到 result数组对应的位置之中
countList[list[k] - min] --; // 使用一次后,累计的数量自减,防止重复使用导致错误
}
list.splice(0, len, ...result); // 重新洗牌,用 result 内元素替换
}
function maximumGap(nums: number[]): number {
// 如果数组长度小于2返回0
if (nums.length < 2) return 0;
countSort(nums);
// 用它来保存相邻元素的最大差值
let max = 0;
for (let i = 1; i < nums.length; i++) max = Math.max(max, nums[i] - nums[i - 1]);
return max;
};
- 参考: https://blog.youkuaiyun.com/Tyro_java/article/details/134172583
- 备注:可以做,但计数排序更适用于密集型数据,不适合这个场景,如果用例数据中有:
[99999999, 2]这类,则非常低效 - 无法通过 leetcode 的测试用例
4 )桶排序
function maximumGap(nums: number[]): number {
const n: number = nums.length;
if (n < 2) return 0;
const minVal: number = Math.min(...nums);
const maxVal: number = Math.max(...nums);
const d: number = Math.max(1, Math.floor(maxVal - minVal) / (n - 1));
const bucketSize = Math.floor((maxVal - minVal) / d) + 1;
const bucket: number[][] = new Array(bucketSize).fill(0).map(x => new Array(2).fill(0));
for (let i: number = 0; i < bucketSize; ++i) {
bucket[i].fill(-1);
}
for (let i: number = 0; i < n; i++) {
const idx: number = Math.floor((nums[i] - minVal) / d);
if (bucket[idx][0] === -1) {
bucket[idx][0] = bucket[idx][1] = nums[i];
} else {
bucket[idx][0] = Math.min(bucket[idx][0], nums[i]);
bucket[idx][1] = Math.max(bucket[idx][1], nums[i]);
}
}
let max: number = 0;
let prev: number = -1;
for (let i: number = 0; i < bucketSize; i++) {
if (bucket[i][0] == -1) {
continue;
}
if (prev != -1) {
max = Math.max(max, bucket[i][0] - bucket[prev][1]);
}
prev = i;
}
return max;
};
- 官方提供的 桶排序 解题思路
Python3 版算法实现
1 ) 方案1
class Solution:
def maximumGap(self, nums: List[int]) -> int:
# 如果数组长度小于2返回0
if len(nums) < 2:
return 0
# 排序
nums.sort()
# 用它来保存相邻元素的最大差值
max_gap = 0
for i in range(1, len(nums)):
max_gap = max(max_gap, nums[i] - nums[i - 1])
return max_gap
2 ) 方案2
class Solution:
def maximumGap(self, nums: List[int]) -> int:
# 如果数组长度小于2返回0
if len(nums) < 2:
return 0
self.radix_sort(nums)
# 用它来保存相邻元素的最大差值
max_gap = 0
for i in range(1, len(nums)):
max_gap = max(max_gap, nums[i] - nums[i - 1])
return max_gap
def radix_sort(self, lst: list) -> None:
max_val = max(lst) # 获取数组中最大值
radix = 1 # 基数(个:1, 十:10, 百: 100, ...)
while max_val >= radix:
bucket = [0] * 10 # 初始化存储桶 0 ~ 9, 全0填充
tmp = [0] * len(lst) # 临时倒腾数组
# 对当前基数下的值进行累加计算总数
for num in lst:
current_radix_num = (num // radix) % 10
bucket[current_radix_num] += 1
# 计算当前数据位置: 基于桶内每个下标对应数据的累计个数,计算当前元素在整个桶中的位置,并反向赋值给当前桶
for i in range(1, 10):
bucket[i] += bucket[i - 1]
# 将lst[i]的值按照桶存储的位置倒腾到临时数组tmp中
for i in range(len(lst) - 1, -1, -1):
current_radix_num = (lst[i] // radix) % 10
current_index = bucket[current_radix_num] - 1
tmp[current_index] = lst[i]
bucket[current_radix_num] -= 1
# 再将临时数组中的元素倒腾回lst中,此时完成了一轮的基于基数的处理
lst[:] = tmp[:]
radix *= 10 # 基数进位处理
3 ) 方案3
class Solution:
def maximumGap(self, nums: List[int]) -> int:
# 如果数组长度小于2返回0
if len(nums) < 2:
return 0
self.count_sort(nums)
# 用它来保存相邻元素的最大差值
max_gap = 0
for i in range(1, len(nums)):
max_gap = max(max_gap, nums[i] - nums[i - 1])
return max_gap
def count_sort(self, lst: list) -> None:
if len(lst) < 2:
return
max_val = max(lst) # 获取最大值
min_val = min(lst) # 获取最小值
count_list = [0] * (max_val - min_val + 1) # 初始化计数数组
result = [0] * len(lst) # 初始化目标数组
# 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
for num in lst:
count_list[num - min_val] += 1
# 计算位置: 由上面的累计结果,计算累加后的位置, countList数组从累计数组,变成了位置数组
for i in range(1, len(count_list)):
count_list[i] += count_list[i - 1]
# 根据累加后的位置, 将原数组中的数据按照位置进行分配,就得到排好序的数组
for i in range(len(lst) - 1, -1, -1):
current_index = count_list[lst[i] - min_val] - 1
result[current_index] = lst[i]
count_list[lst[i] - min_val] -= 1
# 重新洗牌,用 result 内元素替换
lst[:] = result[:]
- 这种超出内存限制
4 ) 方案4
class Solution:
def maximumGap(self, nums: List[int]) -> int:
n = len(nums)
if n < 2:
return 0
min_val = min(nums)
max_val = max(nums)
d = max(1, (max_val - min_val) // (n - 1))
bucket_size = ((max_val - min_val) // d) + 1
bucket = [[-1, -1] for _ in range(bucket_size)]
for num in nums:
idx = (num - min_val) // d
if bucket[idx][0] == -1:
bucket[idx][0] = bucket[idx][1] = num
else:
bucket[idx][0] = min(bucket[idx][0], num)
bucket[idx][1] = max(bucket[idx][1], num)
max_gap = 0
prev = -1
for i in range(bucket_size):
if bucket[i][0] == -1:
continue
if prev != -1:
max_gap = max(max_gap, bucket[i][0] - bucket[prev][1])
prev = i
return max_gap
Golang 版算法实现
1 ) 方案1
func maximumGap(nums []int) int {
// 如果数组长度小于2返回0
if len(nums) < 2 {
return 0
}
// 排序
sort.Ints(nums)
// 用它来保存相邻元素的最大差值
maxGap := 0
for i := 1; i < len(nums); i++ {
maxGap = max(maxGap, nums[i]-nums[i-1])
}
return maxGap
}
2 ) 方案2
func radixSort(list []int) {
maxVal := max(list...)
radix := 1
tmp := make([]int, len(list))
for maxVal/radix > 0 {
bucket := make([]int, 10)
for _, num := range list {
currentRadixNum := (num / radix) % 10
bucket[currentRadixNum]++
}
for i := 1; i < 10; i++ {
bucket[i] += bucket[i-1]
}
for i := len(list) - 1; i >= 0; i-- {
currentRadixNum := (list[i] / radix) % 10
currentIndex := bucket[currentRadixNum] - 1
tmp[currentIndex] = list[i]
bucket[currentRadixNum]--
}
copy(list, tmp)
radix *= 10
}
}
func maximumGap(nums []int) int {
// 如果数组长度小于2返回0
if len(nums) < 2 {
return 0
}
radixSort(nums)
// 用它来保存相邻元素的最大差值
maxGap := 0
for i := 1; i < len(nums); i++ {
maxGap = max(maxGap, nums[i]-nums[i-1])
}
return maxGap
}
func max(nums ...int) int {
maxVal := nums[0]
for _, num := range nums[1:] {
if num > maxVal {
maxVal = num
}
}
return maxVal
}
3 ) 方案3
func maximumGap(nums []int) int {
// 如果数组长度小于2返回0
if len(nums) < 2 {
return 0
}
countSort(nums)
// 用它来保存相邻元素的最大差值
maxGap := 0
for i := 1; i < len(nums); i++ {
maxGap = max(maxGap, nums[i]-nums[i-1])
}
return maxGap
}
func countSort(lst []int) {
if len(lst) < 2 {
return
}
maxVal := max(lst...)
minVal := min(lst...)
rangeVal := maxVal - minVal + 1
countList := make([]int, rangeVal)
result := make([]int, len(lst))
// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
for _, num := range lst {
countList[num-minVal]++
}
// 计算位置: 由上面的累计结果,计算累加后的位置, countList数组从累计数组,变成了位置数组
for i := 1; i < len(countList); i++ {
countList[i] += countList[i-1]
}
// 根据累加后的位置, 将原数组中的数据按照位置进行分配,就得到排好序的数组
for i := len(lst) - 1; i >= 0; i-- {
currentIndex := countList[lst[i]-minVal] - 1
result[currentIndex] = lst[i]
countList[lst[i]-minVal]--
}
// 重新洗牌,用 result 内元素替换
copy(lst, result)
}
func max(nums ...int) int {
maxVal := nums[0]
for _, num := range nums[1:] {
if num > maxVal {
maxVal = num
}
}
return maxVal
}
func min(nums ...int) int {
minVal := nums[0]
for _, num := range nums[1:] {
if num < minVal {
minVal = num
}
}
return minVal
}
- 超出内存限制
4 ) 方案4
func maximumGap(nums []int) int {
n := len(nums)
if n < 2 {
return 0
}
minVal := minArray(nums)
maxVal := maxArray(nums)
d := max(1, (maxVal-minVal)/(n-1))
bucketSize := (maxVal-minVal)/d + 1
// 初始化桶
bucket := make([][2]int, bucketSize)
for i := range bucket {
bucket[i] = [2]int{-1, -1}
}
// 将每个元素放入相应的桶中
for _, num := range nums {
idx := (num - minVal) / d
if bucket[idx][0] == -1 {
bucket[idx][0] = num
bucket[idx][1] = num
} else {
bucket[idx][0] = min(bucket[idx][0], num)
bucket[idx][1] = max(bucket[idx][1], num)
}
}
// 计算最大差值
maxGap := 0
prev := -1
for i := 0; i < bucketSize; i++ {
if bucket[i][0] == -1 {
continue
}
if prev != -1 {
maxGap = max(maxGap, bucket[i][0]-bucket[prev][1])
}
prev = i
}
return maxGap
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
func min(a, b int) int {
if a < b {
return a
}
return b
}
// 辅助函数:计算数组的最小值
func minArray(nums []int) int {
minVal := nums[0]
for _, num := range nums[1:] {
if num < minVal {
minVal = num
}
}
return minVal
}
// 辅助函数:计算数组的最大值
func maxArray(nums []int) int {
maxVal := nums[0]
for _, num := range nums[1:] {
if num > maxVal {
maxVal = num
}
}
return maxVal
}
1484



被折叠的 条评论
为什么被折叠?



