【日常系列】LeetCode《7·排序篇》

已于 2023-08-05 20:24:36 修改
阅读量284 收藏
点赞数
分类专栏： 《数据结构与算法入门》 文章标签： leetcode 算法 数据结构
于 2022-08-18 15:42:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42889517/article/details/126354648
版权

数据规模->时间复杂度

<=10^4 😮(n^2)
<=10^7:o(nlogn)
<=10^8:o(n)
10^8<=:o(logn),o(1)

总结

1.回顾常用排序算法
2.各排序算法的应用(归并、快排)
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
小规模数据，选择使用O(n^2)的排序算法
大规模数据,选择使用O(nlogn)的排序算法

1)如何写一个通用的排序算法
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

2)排序元素比较
3)分治算法思想

3.自定义排序的逻辑
4.有的时候,先对数据进行排序，可以降低复杂度

lc 912 ：https://leetcode.cn/problems/sort-an-array/
提示：
1 <= nums.length <= 5 * 10^4
-5 * 10^4 <= nums[i] <= 5 * 10^4

#方案一：归并
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        #o(n)
        self.sort_merge(nums,0,len(nums)-1,[0]*len(nums))
        return nums
    #o(nlogn):分治 
    def sort_merge(self, nums,lo,hi,tmp) -> None:
        #递归终止条件：最小子问题，无法继续分解
        if lo>=hi:return 
        #
        mid=lo+(hi-lo)//2
        self.sort_merge(nums,lo,mid,tmp)
        self.sort_merge(nums,mid+1,hi,tmp)
        self.merge(nums,lo,mid,hi,tmp)
    #归并
    def merge(self, nums,lo,mid,hi,tmp) -> None:
        #
        for i in range(lo,hi+1):
            tmp[i]=nums[i]
        #
        i=lo
        j=mid+1
        for k in range(lo,hi+1):
            if i==mid+1: #key
                nums[k]=tmp[j]
                j+=1
            elif j==hi+1: #key
                nums[k]=tmp[i]
                i+=1
            elif tmp[i]<=tmp[j]:
                nums[k]=tmp[i]
                i+=1
            else:
                nums[k]=tmp[j]
                j+=1
#方案二：二路快排:o(nlogn),o(logn)
import random
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        self.quick_sort(nums,0,len(nums)-1)
        return nums
    #o(nlogn):分治 
    def quick_sort(self,nums,lo,hi) -> None:
        #
        if lo>=hi:return 
        #
        index=self.pivot(nums,lo,hi)
        self.quick_sort(nums,lo,index-1)
        self.quick_sort(nums,index+1,hi)
        
    #快排：o(nlogn)
    def pivot(self, nums,lo,hi) -> None:
        #随机选取pivot
        i = random.randint(lo, hi)
        nums[i],nums[hi]=nums[hi],nums[i] #换至最后，方便分区
        pivot=nums[hi]
        #分区
        less=great=lo
        while great<=hi-1:
            if nums[great]<pivot:
                nums[less],nums[great]=nums[great],nums[less]
                less+=1
            great+=1
        nums[less],nums[great]=nums[great],nums[less]
        #
        return less     
#三路快排：o(nlogn),o(logn)
import random
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        self.quick_sort(nums,0,len(nums)-1)
        return nums
    #o(nlogn):分治 
    def quick_sort(self,nums,lo,hi) -> None:
        #
        if lo>=hi:return 
        #
        less,great=self.pivot(nums,lo,hi)
        self.quick_sort(nums,lo,less-1)
        self.quick_sort(nums,great+1,hi)
        
    #三路快排：o(nlogn)
    def pivot(self, nums,lo,hi) -> None:
        #随机选取pivot
        j = random.randint(lo, hi)
        nums[j],nums[hi]=nums[hi],nums[j] #换至最后，方便分区
        pivot=nums[hi]
        #分区：未处理区[great,hi],其他为已处理区
        i=lo
        less=lo
        great=hi
        while i<=great:
            if nums[i]<pivot:
                nums[less],nums[i]=nums[i],nums[less]
                less+=1
                i+=1#注意：nums[i]与nums[less]已经得到处理
            elif nums[i]>pivot:
                nums[great],nums[i]=nums[i],nums[great]
                great-=1
                #注意无i+=1：此时nums[i]为待处理元素，因为之前nums[great]不明情况
            else:i+=1          
        #
        return less,great

阿里面试题 - 快速查找第二大数
在这里插入图片描述

#冒泡：时o(n),空o(1)
class Solution:
    def getsecondmax(self, nums: List[int]) -> List[int]:
    	#
    	first=-2**31
    	second=-2**31
    	#
    	for num in nums:
    		if num>first:
    			second=first
    			first=num
    		else:num>second:
    			second=num
    	#
    	return second

lc 628 ：https://leetcode.cn/problems/maximum-product-of-three-numbers/
提示：
3 <= nums.length <= 10^4
-1000 <= nums[i] <= 1000

#冒泡
class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        #o(1)
        #第一小，第二小
        min1=min2=float('inf')
        #第一大，第二大，第三大
        max1=max2=max3=float('-inf')
        #o(n)
        for num in nums:
            min1,min2,_=sorted([min1,min2,num])
            _,max3,max2,max1=sorted([max1,max2,max3,num])
        #
        return max(max1*max2*max3,min1*min2*max1)

lc 88：https://leetcode.cn/problems/merge-sorted-array/
提示：
nums1.length == m + n
nums2.length == n
0 <= m, n <= 200
1 <= m + n <= 200
-10^9 <= nums1[i], nums2[j] <= 10^9

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        #o(1)
        i=m-1
        j=n-1
        k=n+m-1
        #o(n):nums1，nums2已经有序
        while j>=0:
            if i>=0 and nums1[i]>nums2[j]:
                nums1[k]=nums1[i]
                i-=1
            else:
                nums1[k]=nums2[j]
                j-=1
            k-=1
        #
        return nums1

【剑指 51】：https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof/
限制：
0 <= 数组长度 <= 50000

#逆序对:数组中的两个元素，前面的元素大于后面的元素
#方案一：暴力（超时）
class Solution:
    def reversePairs(self, nums: List[int]) -> int:
        #
        if nums==None or len(nums)<2:return 0
        #o(n^2)
        count=0
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                if nums[i]>nums[j]:
                    count+=1
        #
        return count 
        
#方案二：归并（阶段排序）：整序的过程是消逆序对（有序程度）的过程
#分治算法：类比栈（先进后出）与 DFS(深度优先遍历)
#https://www.bilibili.com/video/BV1Qk4y1r7u5?spm_id_from=333.337.search-card.all.click
class Solution:
    def reversePairs(self, nums: List[int]) -> int:
        #
        if len(nums)<2:return 0
        #o(n),o(nlogn)
        copy=[0]*len(nums) #不改变原数组
        for i in range(len(nums)):
            copy[i]=nums[i]

        count=self.sort_merge_count(copy,0,len(nums)-1,[0]*len(nums))
        return count

    def sort_merge_count(self,copy,lo,hi,tmp) -> int:
        #
        if lo==hi:return 0 #只有一个元素，一定有序，一定非逆序数
        #  
        mid=lo+(hi-lo)//2 #解决整形溢出问题
        n1=self.sort_merge_count(copy,lo,mid,tmp)
        n2=self.sort_merge_count(copy,mid+1,hi,tmp)
        #优化-已经有序
        if copy[mid]<=copy[mid+1]:
            return n1+n2
        n3=self.merge(copy,lo,mid,hi,tmp)
        #
        return n1+n2+n3
    #copy[left,mid],copy[mid+1,right]已经排好序 
    def merge(self,copy,lo,mid,hi,tmp) -> int:
        #
        for i in range(lo,hi+1):
            tmp[i]=copy[i]
        #
        i=k=lo
        j=mid+1
        count=0
        while 0<=k<=hi: #key
            if i==mid+1:
                copy[k]=tmp[j]
                j+=1
            elif j==hi+1:
                copy[k]=tmp[i]
                i+=1
            elif tmp[i]<=tmp[j]: #=:保证稳定排序
                copy[k]=tmp[i]
                i+=1
            else: 
                copy[k]=tmp[j]
                j+=1
                count+=mid-i+1 #key：利用部分数组的有序性
            k+=1
        return count

lc 315：https://leetcode.cn/problems/count-of-smaller-numbers-after-self/
提示：
1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4

class Solution:
    def countSmaller(self, nums: List[int]) -> List[int]:
        #nums->index tmp->tmpindex
        n=len(nums)
        self.index=[i for i in range(n)]
        self.tmp=[0]*n
        self.tmpindex=[0]*n #key：绑定元素和对应的索引
        #o(n)
        self.res=[0]*n
        self.sort_merge(nums,0,n-1)
        return self.res
        
    
    #o(nlogn):分治 
    def sort_merge(self, nums,lo,hi) -> None:
        #递归终止条件：最小子问题，无法继续分解
        if lo==hi:return 
        #
        mid=lo+(hi-lo)//2
        self.sort_merge(nums,lo,mid)
        self.sort_merge(nums,mid+1,hi)
        self.merge(nums,lo,mid,hi)
    #归并
    def merge(self, nums,lo,mid,hi) -> None:
        #
        for i in range(lo,hi+1):
            self.tmp[i]=nums[i]
            self.tmpindex[i]=self.index[i]
        #
        i=lo
        j=mid+1
        for k in range(lo,hi+1):
            if i==mid+1: #key
                nums[k]=self.tmp[j]
                self.index[k]=self.tmpindex[j]
                j+=1
            elif j==hi+1: #key
                nums[k]=self.tmp[i]
                self.index[k]=self.tmpindex[i]
                self.res[self.tmpindex[i]]+=(j-mid-1)
                i+=1
            elif self.tmp[i]<=self.tmp[j]:
                nums[k]=self.tmp[i]
                self.index[k]=self.tmpindex[i]
                self.res[self.tmpindex[i]]+=(j-mid-1) #key优化:i-mid-1:比当前元素小的后面元素的个数
                i+=1
            else:
                nums[k]=self.tmp[j]
                self.index[k]=self.tmpindex[j]
                j+=1

lc 327:https://leetcode.cn/problems/count-of-range-sum/
提示：
1 <= nums.length <= 10^5
-2^31 <= nums[i] <= 2^31 - 1
-10^5 <= lower <= upper <= 10^5
题目数据保证答案是一个 32 位 的整数

#问题转化(前缀和):查找[i,j]对使得: prefixSum[j] - prefixSum[i] ∈ [lower，upper]找到所有符合条件的[i,j]对，其中i!=j
#排序不影响结果：组间是独立的，不影响的
class Solution:
    def countRangeSum(self, nums: List[int], lower: int, upper: int) -> int:
        #前缀和
        n=len(nums)
        prefixsum=[0]*(n+1)
        for i in range(1,n+1):
            prefixsum[i]=prefixsum[i-1]+nums[i-1]
        #
        self.lower=lower
        self.upper=upper
        self.tmp=[0]*(n+1)
        return self.sort_merge(prefixsum,0,n)

    #o(nlogn):分治 
    def sort_merge(self, nums,lo,hi) -> int:
        #递归终止条件：最小子问题，无法继续分解
        if lo==hi:return 0
        #
        mid=lo+(hi-lo)//2
        n1=self.sort_merge(nums,lo,mid)
        n2=self.sort_merge(nums,mid+1,hi)
        #nums[left,mid],nums[mid+1，right]已排序
        count=0
        i=lo
        l=r=mid+1
        while i<=mid:
            while l<=hi and (nums[l]-nums[i])<self.lower:l+=1 #第一个>=lower
            while r<=hi and (nums[r]-nums[i])<=self.upper:r+=1 #第一个>upper
            count+=(r-l)
            i+=1
        #
        self.merge(nums,lo,mid,hi)
        #左半合并过程的统计（最小子问题）+右半合并过程的统计（最小子问题）+左半右半整体合并过程的统计
        return n1+n2+count
    #归并
    def merge(self, nums,lo,mid,hi) -> int:
        #
        for i in range(lo,hi+1):
            self.tmp[i]=nums[i]
        #
        i=lo
        j=mid+1
        for k in range(lo,hi+1):
            if i==mid+1: #key
                nums[k]=self.tmp[j]
                j+=1
            elif j==hi+1: #key
                nums[k]=self.tmp[i]
                i+=1
            elif self.tmp[i]<=self.tmp[j]:
                nums[k]=self.tmp[i]
                i+=1
            else:
                nums[k]=self.tmp[j]
                j+=1

lc 493：https://leetcode.cn/problems/reverse-pairs/
注意:
给定数组的长度不会超过50000。
输入数组中的所有数字都在32位整数的表示范围内。

class Solution:
    def reversePairs(self, nums: List[int]) -> int:
        n=len(nums)
        self.tmp=[0]*n
        return self.sort_merge(nums,0,n-1)

    #o(nlogn):分治 
    def sort_merge(self, nums,lo,hi) -> int:
        #递归终止条件：最小子问题，无法继续分解
        if lo==hi:return 0
        #
        mid=lo+(hi-lo)//2
        n1=self.sort_merge(nums,lo,mid)
        n2=self.sort_merge(nums,mid+1,hi)
        #nums[left,mid],nums[mid+1，right]已排序
        count=0
        i=lo
        j=mid+1
        while i <= mid:
            while j <= hi and (nums[i]-2 * nums[j])>0 : j += 1 #第一个不满足的->前面都满足
            count += (j - mid - 1)#i-mid-1:满足条件的后面元素的个数
            i += 1
        #
        self.merge(nums,lo,mid,hi)
        #左半合并过程的统计（最小子问题）+右半合并过程的统计（最小子问题）+左半右半整体合并过程的统计
        return n1+n2+count
    #归并
    def merge(self, nums,lo,mid,hi) -> int:
        #
        for i in range(lo,hi+1):
            self.tmp[i]=nums[i]
        #
        i=lo
        j=mid+1
        for k in range(lo,hi+1):
            if i==mid+1: #key
                nums[k]=self.tmp[j]
                j+=1
            elif j==hi+1: #key
                nums[k]=self.tmp[i]
                i+=1
            elif self.tmp[i]<=self.tmp[j]:
                nums[k]=self.tmp[i]
                i+=1
            else:
                nums[k]=self.tmp[j]
                j+=1

lc 50 【剑指 16】:https://leetcode.cn/problems/powx-n/
提示：
-100.0 < x < 100.0
-2^31 <= n <= 2^31-1
-10^4 <= xn <= 10^4

#快速幂+递归
#o(logn),o(logn)
class Solution:
    def myPow(self, x: float, n: int) -> float:
        if n<0:
            x=1/x
            n=-n
        return self.quickpow(x,n)

    #递归：O(logn),o(logn)
    def quickpow(self,x,n)->float:
        #
        if n==0:return 1
        if n==1:return x
        #
        mid=n//2
        y=self.quickpow(x,mid)
        #
        return y*y if n%2==0 else x*y*y
        
#优化-结合位运算
class Solution:
    def myPow(self, x: float, n: int) -> float:
        #
        if n<0:
            x=1/x
            n=-n
        #o(32),o(1)
        res=1
        while n!=0:
            if n&1==1 :res*=x #非零位，对结果影响
            #更新
            x*=x #x^2,x^4,x^8......
            n>>=1
        #
        return res

快速排序 - 分区逻辑的应用
未处理区域[great,hi]
二项切分：[<=pivot][>pivot]
在这里插入图片描述
三项切分：[<pivot][=pivot][>pivot]
在这里插入图片描述

lc 75【top100】：https://leetcode.cn/problems/sort-colors/
提示：
n == nums.length
1 <= n <= 300
nums[i] 为 0、1 或 2
进阶：
你可以不使用代码库中的排序函数来解决这道题吗？
你能想出一个仅使用常数空间的一趟扫描算法吗？

#方案一：计数排序:o(n),o(1)
class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        #计数:o(n),o(1)
        count=[0]*3
        for i in range(len(nums)):
            count[nums[i]]+=1
        #排序
        k=0
        for i in range(3):
            n=count[i]
            for j in range(n):
                nums[k]=i
                k+=1
        #
        return nums
        
#方案二：三路快排类比 [==0][==1][==2]
class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        #o(1)
        zero=0
        two=len(nums)-1
        i=0
        #o(n)
        pivot=1
        while i<=two:
            if nums[i]<pivot:
                nums[i],nums[zero]=nums[zero],nums[i]
                i+=1
                zero+=1
            elif nums[i]>pivot:
                nums[i],nums[two]=nums[two],nums[i]
                two-=1
            else:i+=1
        #
        return nums

lc 179【剑指 45】：https://leetcode.cn/problems/largest-number/
提示：
1 <= nums.length <= 100
0 <= nums[i] <= 10^9

import random

class largestNumkey(str):
    def __lt__(x,y):
        return x+y>y+x #富比较

class Solution:
    def largestNumber(self, nums: List[int]) -> str:
        largestNum=''.join(sorted(map(str,nums),key=largestNumkey))
        return largestNum if largestNum[0]!='0'else '0'

lc 56【剑指 74】：区间合并
https://leetcode.cn/problems/merge-intervals/
提示：
1 <= intervals.length <= 10^4
intervals[i].length == 2
0 <= starti <= endi <= 10^4
【计算之魂 11章】

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        # 根据 start_i 进行排序
        intervals.sort(key=lambda x: x[0])
        merged = [intervals[0]]
        for interval in intervals:
            start, end = interval
            # 如果列表为空，或者当前区间与上一区间不重合，直接添加
            if merged[-1][1] < start:
                merged.append(interval)
            # 否则的话，我们就可以与上一区间进行合并
            else:
                merged[-1][1] = max(merged[-1][1], end)
        return merged

lc 57 ：https://leetcode.cn/problems/insert-interval/
提示：
0 <= intervals.length <= 10^4
intervals[i].length == 2
0 <= intervals[i][0] <= intervals[i][1] <= 10^5
intervals 根据 intervals[i][0] 按 升序 排列
newInterval.length == 2
0 <= newInterval[0] <= newInterval[1] <= 10^5

#方案一：
class Solution:
    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
        #
        interval=intervals
        interval.append(newInterval)
        if len(interval)==0:return []
        #o(n),o(1)
        output=[]
        interval.sort(key=lambda x:x[0])
        output.append(interval[0]) #排序后的
        for i in range(1,len(interval)):
            curl,curr=interval[i][0],interval[i][1]
            if curl<=output[-1][1]: #重叠
                output[-1][1]=max(output[-1][1],curr)
            else:output.append(interval[i])
        #
        return output
#方案二：
class Solution:
    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
        #o(n),o(1)
        i=0
        res=[]
        while i<len(intervals) and intervals[i][1]<newInterval[0]:
            res.append(intervals[i])
            i+=1
        #
        while i<len(intervals) and intervals[i][0]<=newInterval[1]:#重叠
            newInterval[0]=min(intervals[i][0],newInterval[0])
            newInterval[1]=max(intervals[i][1],newInterval[1])
            i+=1
        res.append(newInterval)
        #
        while i<len(intervals):
            res.append(intervals[i])
            i+=1
        #
        return res

lc 905：https://leetcode.cn/problems/sort-array-by-parity/
提示：
1 <= nums.length <= 5000
0 <= nums[i] <= 5000

#方案一：暴力解法-O(n),o(n)
class Solution:
    def sortArrayByParity(self, nums: List[int]) -> List[int]:
        #
        res=[0]*len(nums)
        #
        left=0
        right=len(nums)-1
        for i in range(len(nums)):
            if nums[i]%2==0:
                res[left]=nums[i]
                left+=1
            else:
                res[right]=nums[i]
                right-=1
        #
        return res
#方案二：类比二向快排o(n),o(1)
class Solution:
    def sortArrayByParity(self, nums: List[int]) -> List[int]:
        #o(n),o(1)
        double=single=0
        while single<=len(nums)-1:
            if nums[double]%2 > nums[single]%2: #左奇右偶，换位
                nums[double],nums[single]=nums[single],nums[double]
            if nums[double]%2==0:double+=1
            #     double+=1
            # elif nums[single]%2==0:double+=1 #偶+偶
            # #其他：偶+奇
            single+=1
        #
        return nums

#方案三：优化-减少交换次数
class Solution:
    def sortArrayByParity(self, nums: List[int]) -> List[int]:
        #o(n),o(1)
        left=0
        right=len(nums)-1
        while left<=right:
            if nums[left]%2 > nums[right]%2: #左奇右偶，换位
                nums[left],nums[right]=nums[right],nums[left]
            if nums[left]%2==0:left+=1
            if nums[right]%2==1:right-=1
        #
        return nums

lc 922：https://leetcode.cn/problems/sort-array-by-parity-ii/
提示：
2 <= nums.length <= 2 * 10^4
nums.length 是偶数
nums 中一半是偶数
0 <= nums[i] <= 1000
进阶：可以不使用额外空间解决问题吗？

#双指针思路
class Solution:
    def sortArrayByParityII(self, nums: List[int]) -> List[int]:
        #o(1)
        i=0
        j=1
        #o(n)
        while i<=len(nums)-1:
            if nums[i]%2 ==1:
                while nums[j]%2 !=0:j+=2
                nums[i],nums[j]=nums[j],nums[i]
            i+=2
        #
        return nums

lc 1365：https://leetcode.cn/problems/how-many-numbers-are-smaller-than-the-current-number/
提示：
2 <= nums.length <= 500
0 <= nums[i] <= 100

#方案一：超时（快排/归并）
class Solution:
    def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
        #绑定
        n=len(nums)
        data=[[0]*2]*n
        for i in range(n):
            data[i][0]=nums[i]
            data[i][1]=i
        #o(nlogn),o(n)
        data.sort(key=lambda x:x[0])
        i=0
        prev=-1
        res=[0]*n
        while i <n:
            if prev==-1 or data[i]!=data[i-1]:
                prev=i
            res[i]=prev
        #
        return res
        
#计数排序-o(n),o(n)
class Solution:
    def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
        #o(n)
        counts=[0]*(101)
        for num in nums:
            counts[num]+=1
        for i in range(1,101):
            counts[i]+=counts[i-1]
        #o(n)
        res=[0]*len(nums)
        for i in range(len(nums)):
            res[i]=counts[nums[i]-1] if nums[i] !=0 else 0 #key
        #
        return res

lc 164：https://leetcode.cn/problems/maximum-gap/
提示:
1 <= nums.length <= 10^5
0 <= nums[i] <= 10^9

#方案一：桶排序
#平均间距-gap=(max - min)/ (nums.length- 1)
#最大的间距肯定不会小于gap
'''
key：将间距小于gap的所有元素放在一个桶中
bucketNum = nums.length   ∵有可能所有元素间间距都为gap
bucketld =(num -min)/ gap
'''
#桶间有序
import math
class Solution:
    def maximumGap(self, nums: List[int]) -> int:
        n=len(nums)
        if n < 2: return 0  
        #o(n):初始桶 
        buckets_num=n
        INTMAX,INTMIN=2**31-1,-2**31
        buckets=[[INTMAX,INTMIN] for _ in range(buckets_num)] #key
        #o(n:)定义桶
        max_num,min_num=max(nums),min(nums) #变量化（优化）
        if max(nums)==min(nums):return 0
        gap=int(math.ceil((max_num-min_num)/(n-1)))
        for num in nums:
            bucket_id = (num - min_num) // gap
            buckets[bucket_id][0] = min(buckets[bucket_id][0], num)
            buckets[bucket_id][1] = max(buckets[bucket_id][1], num)
        #求最大间隔
        max_gap=0
        prevbucketmax=min_num
        for bucket in buckets:
            if bucket[0]==INTMAX:continue #注 
            max_gap=max(max_gap,bucket[0]-prevbucketmax)
            prevbucketmax=bucket[1]
        return max_gap

#方案二：基数排序-适合数字范围很大（分别比较个位，十位......）
#核心：利用计数排序
class Solution:
    def maximumGap(self, nums: List[int]) -> int:
        n=len(nums)
        data=self.sort(nums)
        #
        gap=0
        for i in range(1,n):
            gap=max(data[i]-data[i-1],gap)
        #
        return gap
 
    #o(n),o(n)
    def sort(self,data):
        #位数
        n=len(data)
        maxnum=0
        for i in range(n):
            maxnum=max(maxnum,data[i])
        exp=1
        while maxnum//exp !=0:
            self.countSort(data,exp)
            exp*=10
        #
        return data

    def countSort(self,data,exp):
        n=len(data)
        count=[0]*10
        #
        for i in range(n):
            count[(data[i]//exp)%10]+=1
        for i in range(1,10):
            count[i]+=count[i-1]
        #
        res=[0]*n
        for i in range(n):
            k=count[(data[i]//exp)%10]-1
            res[k]=data[i]
            count[(data[i]//exp)%10]-=1
        #
        for i in range(n):
            data[i]=res[i]
常某某的好奇心
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode刷题笔记——排序算法篇
qq_42898642的博客
02-16 1190
本文给大家介绍了面试中常考的关于排序问题的算法题，本文重点介绍了计数排序、快速排序、堆排序（重点）、插入排序、归并排序（重点）、桶排序、还有自定义排序规则
LeetCode（七）
weixin_49668199的博客
07-13 124
题目 给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 示例 1： 输入：[1,8,6,2,5,4,8,3,7] 输出：49 示例2 输入：height = [1,1] 输出：1 示例3 输入：height = [4,3,2,1,4] 输出：16 C语言 int maxArea(int* height,
leetcode-排序总结
许诗宇的博客
09-27 280
leetcode-88-合并两个有序数组(merge sorted array)-java 排序两个数组 如果合成的那一列前面有必要的数据，后面没有，那么可以由后向前排序
[leetcode]排序算法（冒泡排序，选择排序，插入排序，快速排序，计数排序）
是安澜啊
12-10 1770
leetcode，排序算法，冒泡排序，python，timeit(),选择排序算法 快速排序，插入排序，归并排序，计数排序
leetcode(七) 基本数据结构
qq_41320429的博客
03-21 294
文章目录1.两数之和（哈希表）187.重复的DNA序列(哈希表)706.设计哈希映射 1.两数之和（哈希表） 算法: 用哈希表unordered_map<int,int>存储元素下标 用指针i遍历整个nums数组,对于每个nums[i]，在哈希表中查找是否存在对应的target-nums[i],如果没有将i的下标存入哈希表 时间复杂度是O(n) class Solution...
leetcode部分排序类-leetcode:我在leetcode.com上的解决方案
06-30
部分排序类leetcode 1. 二和 给定一个整数数组，返回两个数字的索引，使它们相加为特定目标。 您可以假设每个输入都只有一个解决方案，并且您不能两次使用相同的元素。 例子： Given nums = [2, 7, 11, 15], target ...
leetcode部分排序类-LeetCode:力码
06-30
leetcode部分排序类 Summary Summary of LeetCode problems Overall average runtime 就是amortized runtime,注意这个和runtime的差异 题目没有思路的时候考虑极端情况，或许会有启发 避免int 和 .size()-1 比较...
leetcode思维导图-排序
08-13
leetcode思维导图-排序
php-leetcode题解之插入排序.zip
最新发布
06-07
7. **实践应用**：在LeetCode等平台上，通过编写插入排序的代码，可以锻炼对基本算法的理解和实现能力，有助于面试和实际项目开发。 综上所述，这个压缩包包含的文件“php_leetcode题解之插入排序”很可能是一个PHP...
LeetCode 23. 合并K个排序链表
12-21
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。 示例: 输入: [ 1->4->5, 1->3->4, 2->6 ] 输出: 1->1->2->3->4->4->5->6 来源：力扣（LeetCode） 链接：...
LeetCode7 Reverse Integer
01-09
Given a 32-bit signed integer, reverse digits of an integer. Java AC版本
LeetCode力扣刷题——千奇百怪的排序算法
指北针_N的博客
09-26 497
LeetCode力扣，排序算法。快速排序，桶排序，冒泡排序，选择排序，归并排序。先找一个中枢点（pivot），然后遍历其他数字，小于 pivot 的排左边，大于 pivot 的排右边，中枢点是数组中的第几小的数字就确定了，如果 pivot 与 target 相等，直接返回pivot 位置的数字，如果大于 target ，说明要求的数字在左边部分，否则在右边部分。快速排序，而且刷题时很少需要自己手写排序算法，但是熟习各种排序算法可以加深自己对算法的基本理解，以及解出由这些排序算法引申出来的题目。请注意，你需
【LeetCode 排序算法】
qq_62829518的博客
06-20 474
排序算法用作实现列表的排序，列表元素可以是整数，也可以是浮点数、字符串等其他数据类型。生活中有许多需要排序算法的场景
Leetcode 7：整数反转
weixin_75181956的博客
09-03 127
如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。假设环境不允许存储 64 位整数（有符号或无符号）。
leetcode7
m0_61429496的博客
05-05 263
543.给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。 示例 : 给定二叉树 1 / \ 2 3 / \ 4 5 返回3, 它的长度是路径 [4,2,1,3] 或者[5,2,1,3]。 注意：两结点之间的路径长度是以它们之间边的数目表示。 class Solution { int res...
LeetCode 7.整数翻转
Suk_god的博客
10-12 301
文章目录题目描述测试样例思路分析代码实现 题目描述 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。 如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。 假设环境不允许存储 64 位整数（有符号或无符号）。 测试样例 示例 1： 输入：x = 123 输出：321 示例 2： 输入：x = -123 输出：-321 示例 3： 输入：x = 120 输出：21 示例 4： 输入：x = 0 输出：0 提示： -231 <=
leetcode7---整数反转
weixin_40794404的博客
05-12 610
leetcode7—整数反转 题目 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。 如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。 假设环境不允许存储 64 位整数（有符号或无符号）。 示例 1： 输入：x = 123 输出：321 示例 2： 输入：x = -123 输出：-321 示例 3： 输入：x = 120 输出：21 示例 4： 输入：x = 0 输出：0 提示： -231 <= x <=
leetcode-7
shushi6969的博客
02-04 124
https://leetcode-cn.com/problems/reverse-integer/ 思路：最大、最小值提前预判，执行过程中不能存储大于或小于的值。 int reverse(int x) { int sign = 0; //解决输入异常数据 if (x <= INT_MIN || x >= INT_MAX) { return 0; } if (x < 0) { sign = 1; x...
LeetCode第七题: 整数反转(Java)
巨坑的菜比的博客
04-15 3993
题目: 整数反转 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。 如果反转后整数超过 32 位的有符号整数的范围 [−2^31,(2^31 )− 1] ，就返回 0。 假设环境不允许存储 64 位整数（有符号或无符号）。 题目解读： ...
leetcode堆排序
10-12
堆排序是一种基于堆数据结构的排序算法，它的时间复杂度为 O(nlogn)。堆排序分为两个阶段：建堆和排序。建堆的时间复杂度为 O(n)，排序的时间复杂度为 O(nlogn)。 具体实现步骤如下： 1. 将待排序序列构建成一个大根堆（或小根堆），此时整个序列的最大（或最小）值就是堆顶的根节点。 2. 将堆顶元素与末尾元素交换，将最大（或最小）元素“沉”到数组末端。 3. 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。 代码实现如下： ```python def heap_sort(nums): n = len(nums) # 构建大根堆 for i in range(n // 2 - 1, -1, -1): heapify(nums, n, i) # 排序 for i in range(n - 1, 0, -1): nums[0], nums[i] = nums[i], nums[0] heapify(nums, i, 0) def heapify(nums, n, i): largest = i left = 2 * i + 1 right = 2 * i + 2 if left < n and nums[left] > nums[largest]: largest = left if right < n and nums[right] > nums[largest]: largest = right if largest != i: nums[i], nums[largest] = nums[largest], nums[i] heapify(nums, n, largest) ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值