LeetCode 164. 最大间距

164. 最大间距

题目：给定一个无序的数组 nums，返回 数组在排序之后，相邻元素之间最大的差值 。如果数组元素个数小于 2，则返回 0
您必须编写一个在「线性时间」内运行并使用「线性额外空间」的算法。

链接 https://leetcode.cn/problems/maximum-gap/

个人思路

1. 先不考虑「线性时间」的问题，那么直接sort排序，然后迭代找出最大间距即可

class Solution:
    def maximumGap(self, nums: List[int]) -> int:
        nums.sort()
        gap = 0
        for i in range(0,len(nums)-1):
            gap = nums[i+1] - nums[i] if nums[i+1] - nums[i] > gap else gap
        return gap

执行用时：244 ms, 在所有 python3 提交中击败了88.92%的用户
内存消耗：25.9 MB, 在所有 python3 提交中击败了95.81%的用户

2. 之前在使用set时候，看到set好像会自己排序(看到一些信息说是‘对list和tuple具有排序(升序) 对list与tuple包含个位与十位数时候就不排序了 十以内貌似是会排序’)，然后尝试使用set进行计算。接着使用pop又出现一些别的问题，集合的pop好像不遵循一般的规则，刚开始我以为是从最右边弹出，结果他给我弹出最左边的，我按照最左边弹出来写代码，结果有些用例又先弹出最右边，如[1,1000]，后来看到有些人说是‘按照hash值排序 然后删除排序好的最左边一个’，总之，这个方法行不通。

官方思路

1. 基数排序
   一种最简单的思路是将数组排序后再找出最大间距，但传统的基于比较的排序算法（快速排序、归并排序等）均需要 O(NlogN) 的时间复杂度。如果要将时间复杂度降到 O(N)，我们就必须使用其他的排序算法。例如，基数排序可以在 O(N) 的时间内完成整数之间的排序。

class Solution(object):
    def maximumGap(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 1:
            return 0
        m = len(str(max(nums))) #获取最高位数
        last_layer = [nums]
        for i in range(m):
            this_layer = [[] for _ in range(10)]
            for j in last_layer:
                for k in j: #按顺序将m-1位的处理结果(last_layer)重新装到m位的结果中(this_layer)
                    num = (k // (10**i)) % 10 
                    this_layer[num].append(k)
            last_layer = this_layer[:]
        dummy = [] #按顺序填入排序好的数字
        for i in last_layer:
            for j in i:
                dummy.append(j)
        result = 0
        for i in range(len(dummy)-1):
            result = max(result,dummy[i+1] - dummy[i])
        return result

复杂度分析
时间复杂度：O(N)，其中 N 是数组的长度。
空间复杂度：O(N)，其中 N 是数组的长度。

2. 桶排序
   

   

class Solution:
    def maximumGap(self, nums: List[int]) -> int:
        if len(nums) < 2: return 0
        
        # 一些初始化
        max_ = max(nums)
        min_ = min(nums)
        max_gap = 0
        
        each_bucket_len = max(1,(max_-min_) // (len(nums)-1))
        buckets =[[] for _ in range((max_-min_) // each_bucket_len + 1)]
        
        # 把数字放入桶中
        for i in range(len(nums)):
            loc = (nums[i] - min_) // each_bucket_len
            buckets[loc].append(nums[i])
        
        # 遍历桶更新答案
        prev_max = float('inf')
        for i in range(len(buckets)):
            if buckets[i] and prev_max != float('inf'):
                max_gap = max(max_gap, min(buckets[i])-prev_max)
            
            if buckets[i]:
                prev_max = max(buckets[i])
                
        return max_gap

复杂度分析
时间复杂度：O(N)，其中 N 是数组的长度。注意到桶的数量为(max−min)/d≈N−1=O(N)。
空间复杂度：O(N)，其中 N 是数组的长度。我们开辟的空间大小取决于桶的数量。

参考：
作者：LeetCode-Solution
链接：https://leetcode.cn/problems/maximum-gap/solution/zui-da-jian-ju-by-leetcode-solution/
与桶排序
作者：musiala
链接：https://leetcode.cn/problems/maximum-gap/solution/python3-tong-pai-xu-by-yanghk/
与基数排序
作者：kris311
链接：https://leetcode.cn/problems/maximum-gap/solution/python-ji-shu-pai-xu-by-kris311-hgwk/