以空间换时间的排序（不发生交换的排序）

最新推荐文章于 2024-08-06 20:16:36 发布

李润泽

最新推荐文章于 2024-08-06 20:16:36 发布

阅读量1.4k

点赞数

分类专栏：算法文章标签： python 桶排序算法

本文链接：https://blog.csdn.net/Arnold_lee_yc/article/details/78067128

版权

算法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

（1）桶排序

给定数组，数组中的元素的值>=0,有可能重复， 进行排序，但算法复杂度为恒定， 不允许交换

桶排序 线性排序的基础
待排数组     5 4 9 2   N
s数组的值     0 0 [1 0 1 1 0 0 0 1]   M   将下标取出即为排好序的数组
s数组下标          0 1 2 3 4 5 6 7
参考下标      0 1  2 3 4 5 6 7 8 9
时间复杂度 M+N

先要确定新数组大小，存默认值0
循环oldList到新数组找对应的索引位置，将值+1
循环新数组，将对应的索引位置的数取出，判断是否为0，不为0，oldList中；将索引加1。

# !/usr/bin//env python
# coding=utf-8

import random # 随机数模块

# 桶排序
class bucketSort():
    # 求最大最小值
    def getInfo(self,oldList):
        max=oldList[0]
        min=oldList[0]
        for temp in oldList:
            if temp>max:
                max=temp
            if temp<min:
                min=temp
        return (max,min,max-min)

    def sort(self,oldList):
        max,min,length=self.getInfo(oldList)
        # 先要确定新数组的大小，存默认值0
        s=[0 for i in range(min,max+1)]

        # 循环oldList，到新数组找对应的索引位置，将值+1
        for i in oldList:
            s[i-min]+=1
        current=min # 记录最小值
        index=0 # 用于指示 oldList中的索引

        # 循环新数组，将对应的索引位置的数取出，判断是否为0，不为0，oldList中；将索引加1。
        for i in s:
            # 要循环i的值，因为i代表这个数字重复几次
            while i>0:
                oldList[index]=current
                i-=1    # 当有两个重复值的时候起作用
                index+=1
            current+=1
        return oldList


a=[random.randint(0,100) for i in range(10)]
print a
b=bucketSort()
a=b.sort(a)
print a

（2）基数排序

基数排序：一般用于长度相同的元素（不相同补0）组成的数组，首先按照最低有效数字排序，再由低到高位排序
稳定排序  基于桶排序 空间换时间
原理
 64 5 33 2234 164
 第一次排 按个位桶排

            164
            2234
          33 64 5
 0  1  2  3  4  5  6  7  8  9

 第二次排 按十位桶排

         2234      164
 5        33       64
 0  1  2  3  4  5  6  7  8  9

 第三次排 按百位桶排
 64
 33
 5 164 2234
 0  1  2  3  4  5  6  7  8  9

 第四次排 按千位
 164
 64
 33
 5    2234
 0  1  2  3  4  5  6  7  8  9

# !/usr/bin//env python
# coding=utf-8

import random # 随机数模块

class radixSort:
    # oldlist:要排序的数组
    # numMaxLength:数字最大位
    def sort(self,oldlist,numMaxLength):
        # 根据numMaxLength来循环，表示有几位循环几次
        for k in range(numMaxLength):
            # 生成十进制的一个二维数组，用于存每一位的数字
            s=[[] for i in range(10)]
            # 循环oldlist,将每个数字i存到这个二维数组中对应的位置：i要存的位置如何计算：
            # 先计算二维数组的第几行（表示数字的第几位） i//(10**k)
            # 再计算当前是数字几 上面的结果 %10，再利用数组的append存进去
            for i in oldlist:
                s[i//(10**k)%10].append(i)
            # 本次循环的结果存入到oldlist中
            oldlist=[a for b in s for a in b] # 双重循环
        return oldlist


a=[random.randint(0,9999) for i in range(10)]
b=radixSort()
print a
a=b.sort(a,4)
print a

（3）计数排序

待排序     1 3 5 3
c数组的值  0 1 0 2 0 1
c数组下标  0 1 2 3 4 5
b数组的值  1 3 3 5
b数组下标  0 1 2 3

# !/usr/bin//env python
# coding=utf-8

import random # 随机数模块

# 计数排序：对数组中的每一个元素x，确定出小于x的元素个数，这样就可以将x输出到正确位置了
class countingSort:
    # oldlist:待排序数组
    # k：数组中的最大值
    def sort(self,oldlist,k):
        # 定义一个数组b,存排好序的数组
        b=[0 for i in range(len(oldlist))]
        # 定义一个数组c，存从0-k的序列中每个数字对应的比它小的数字的个数
        c=[0 for i in range(k+1)]
        # 循环oldlist得到每个元素i，按i作索引存好元素出现的次数，以备后面的累加
        for i in oldlist:      # 1 3 5 3
            c[i]+=1            # c[1]=1 c[2]=0 c[3]=2 c[4]=0 c[5]=1
        # 循环数组c，计算每个位置上比它小的数字的个数，并重新存到c对应的位置
        for i in range(1,len(c)):
            c[i]=c[i-1]+c[i]   # c[1]=1 c[2]=1 c[3]=3 c[4]=3 c[5]=4
        # 循环 oldlist,将每个元素存入b对应的位置：对应位置的确认由小于它的元素的个数决定
        for i in oldlist:
            b[c[i]-1]=i
            c[i]-=1
        # 返回b
        return b

a=[random.randint(0,9999) for i in range(10)]
print a
b=countingSort()
a=b.sort(a,9999)
print a