利用排序算法解决的一些问题（Python实现）

最新推荐文章于 2022-09-13 11:04:00 发布

原创最新推荐文章于 2022-09-13 11:04:00 发布 · 380 阅读

0 ·

CC 4.0 BY-SA版权

数据结构与算法同时被 2 个专栏收录

21 篇文章

订阅专栏

Python

2 篇文章

订阅专栏

本文深入探讨了排序算法在解决小和问题、逆序对问题及寻找排序后相邻两数最大差值问题上的应用。通过对比不同算法的时间与空间复杂度，展示了高效算法的设计与实现。同时，提供了基于比较与非比较排序的解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

摘要：排序算法的一些实际应用，如小和问题，逆序对问题，基于非比较排序的相邻两数最大差值问题，

# -*- coding: utf-8 -*-
"""
@project  :   Python_
@author   :   'Zheng Guoliang'
@File     :   Class2.py
@Function :   
@Time     :   2018/12/23 15:51

"""

import  random
import  copy

class Sort_Use(object):
    # 小和问题  时间复杂度0(NlogN)  空间复杂度0(N)
    def Small_Sum(self,nums):
        if len(nums)<2:
            return 0
        return self.Merge_Sort(nums,0,len(nums)-1)
    def Merge_Sort(self,nums,L,R):
        if L>=R:
            return 0
        mid=L+((R-L)>>1)
        return self.Merge_Sort(nums,L,mid)+self.Merge_Sort(nums,mid+1,R)+self.Merges(nums,L,mid,R)
    def Merges(self,nums,L,mid,R):
        i=L
        j=mid+1
        help=[]
        res=0
        while i<=mid and j<=R:
            if nums[i]<nums[j]:
                help.append(nums[i])
                res+=(R-j+1)*nums[i]
                i+=1
            else:
                help.append(nums[j])
                j+=1
        while i<=mid:
            help.append(nums[i])
            i+=1
        while j<=R:
            help.append(nums[j])
            j+=1
        for i in range(0,R-L+1):
            nums[i+L]=help[i]
        return res

    # 小和问题  时间复杂度0(N^2)  空间复杂度0(1)
    def Small_Sum1(self,nums):
        if len(nums)<2:
            return
        res=0
        for i in range(1,len(nums)):
            for j in  range(i-1,-1,-1):
                if nums[i]>nums[j]:
                    res+=nums[j]
        return res

    # 逆序对问题  时间复杂度0(NlogN)  空间复杂度0(N)
    def Reverse_Order(self,nums):
        if len(nums)<2:
            return 0
        return self.Merge_Sort_Order(nums,0,len(nums)-1)
    def Merge_Sort_Order(self,nums,L,R):
        if L>=R:
            return 0
        mid=L+((R-L)>>1)
        return self.Merge_Sort_Order(nums,L,mid)+self.Merge_Sort_Order(nums,mid+1,R)+self.Merges_Order(nums,L,mid,R)
    def Merges_Order(self,nums,L,mid,R):
        i=L
        j=mid+1
        res=0
        help=[]
        while i<=mid and j<=R:
            if nums[i]<=nums[j]:
                help.append(nums[i])
                i+=1
            else:
                help.append(nums[j])
                res+=(mid-i+1)
                j+=1
        while i<=mid:
            help.append(nums[i])
            i+=1
        while j<=R:
            help.append(nums[j])
            j+=1
        for i in range(0,R-L+1):
            nums[i+L]=help[i]
        return res

    # 逆序对问题  时间复杂度0(N^2)  空间复杂度0(1)
    def Reverse_Order1(self,nums):
        if len(nums)<2:
            return 0
        res=0
        for i in range(0,len(nums)-1):
            for j in range(i+1,len(nums)):
                if nums[i]>nums[j]:
                    res+=1
        return res

    #若排序后，相邻两数最大差值，不能用非基于比较的排序  时间复杂度0(N) 空间复杂度0(N)
    def Max_Gap(self,nums):
        if len(nums)<2:
            return 0
        MAX=nums[0]
        MIN=nums[0]
        for i in range(1,len(nums)):
            MAX=max(MAX,nums[i])
            MIN=min(MIN,nums[i])
        if MAX == MIN :
            return 0
        lens=len(nums)
        max_vec=[0 for i in range(lens+1)]
        min_vec=[0 for i in range(lens+1)]
        has_vec=[False  for i in range(lens+1)]
        for i in range(lens):
            pos=int((nums[i]-MIN)*lens/(MAX-MIN))
            max_vec[pos]=max(max_vec[pos],nums[i])  if has_vec[pos] else nums[i]
            min_vec[pos]=min(min_vec[pos],nums[i])  if has_vec[pos] else nums[i]
            has_vec[pos]=True
        res=0
        last_max=max_vec[0]
        for i in range(1,lens+1):
            if has_vec[i]:
                res=max(res,min_vec[i]-last_max)
                last_max=max_vec[i]
        return res

    #若排序后，相邻两数最大差值，基于比较的排序  时间复杂度0(NlogN) 空间复杂度0(1)
    def Max_Gap1(self,nums):
        if len(nums)<2:
            return 0
        nums.sort()
        res=0
        for i in range(1,len(nums)):
            res=max(res,nums[i]-nums[i-1])
        return res

 
def generate_data(n, L, R):
    list = []
    for i in range(n):
        a = random.randint(L, R)
        list.append(a)
        # print(a,end=" ")
    # print(end="\n")
    return list

def Print_data(nums):
    for i in nums:
        print(i, end=" ")



if __name__ == '__main__':
    zgl=Sort_Use()
    flag=True
    for i in range(1,1000):
        nums=generate_data(100,1,100)
        nums1=copy.deepcopy(nums)
        res=zgl.Max_Gap(nums)
        res1=zgl.Max_Gap1(nums1)
        if res!=res1:
            print("error , res:",res," res1:",res1)
            flag=False
            break
    if not flag:
        print("error")
    else:
        print("ok")