算法基础篇——线性时间非比较排序算法

注: 关于非线性时间得比较排序算法请看我得另一篇博客https://blog.csdn.net/weixin_41806489/article/details/104768908

1、计数排序

主要思想：获取待排序数组得最大值和最小值，然后开辟一个从最小值到最大值得连续的数组，该数组数组头是最小值，数组尾是最大值。根据数组中数字相对于最小值最大值的大小存储在相应得位置。所以该算法适合进行整数得排序，有理数排序不太适用。

def countSort(sortList):
    result = []
    if len(sortList)==0:
        print("输入数组为空")
        pass
    else:
        ##找最大值最小值
        maxNum=sortList[0]
        minNum=sortList[0]
        for item in sortList:
            if item>maxNum:
                maxNum=item
            if item<minNum:
                minNum=item
        ##接下来开辟计数数组
        numList=[[] for i in range(maxNum-minNum+1)]
        for item in sortList:
            numList[item-minNum].append(item)
        for ilist in numList:
            for j in ilist:
                result.append(j)
    return result
sortList=[9,1,3,5,8,3,2,9,4]
print(countSort(sortList))

2、桶排序

主要思想：工作的原理是将数组分到有限数量的桶子里。每个桶子再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n）），但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。桶排序是计数排序的一个优化，因为计数排序的过程中如果这个数列中最大值与最小值的跨度比较大的化，很容易产生一个占位很大的中间数组，为了解决这个问题，可以人为的确定中间数组的大小，然后在每个小数桶内进行排序。（下面得代码每个小桶内通过计数排序进行再排序）

def BocketSort(list,bocketSize):
    #传入两个参数，待分配数组和桶的大小
    maxNum = list[0]
    minNum = list[0]
    for item in list:
        if item > maxNum:
            maxNum = item
        if item < minNum:
            minNum = item
    bocketList=[[] for i in bocketSize]
    eveBocketSize=(maxNum-minNum+1)/bocketSize
    for item in list:
        bocketList[(item-minNum)//bocketSize].append(item)
    result=[]
    for evList in bocketList:
        result+=countSort(evList)
    return result

def countSort(sortList):##计数排序
    result = []
    if len(sortList)==0:
        print("输入数组为空")
        pass
    else:
        ##找最大值最小值
        maxNum=sortList[0]
        minNum=sortList[0]
        for item in sortList:
            if item>maxNum:
                maxNum=item
            if item<minNum:
                minNum=item
        ##接下来开辟计数数组
        numList=[[] for i in range(maxNum-minNum+1)]
        for item in sortList:
            numList[item-minNum].append(item)
        for ilist in numList:
            for j in ilist:
                result.append(j)
    return result
sortList=[9,1,3,5,8,3,2,9,4]
print(BocketSort(sortList,5))

3、基数排序

主要思想：（低位到高位的排序方法）先通过个位进行排序，然后通过10位进行排序，依次往上推，当最高位排完以后整个队列实现有序。
对于数组[19,12,53,75,38,73,27,49,46,81,193,76,98,34,51,23,46]，应用基数排序过程如下：
根据个位排序
[81, 51, 12, 53, 73, 193, 23, 34, 75, 46, 76, 46, 27, 38, 98, 19, 49]
将上面数组根据十位排序，这样就保证了10位相同的个位小的在前面。
[12, 19, 23, 27, 34, 38, 46, 46, 49, 51, 53, 73, 75, 76, 81, 193, 98]
最后根据百位排序
[12, 19, 23, 27, 34, 38, 46, 46, 49, 51, 53, 73, 75, 76, 81, 98, 193]

##从低位到高位排序
def radixSort(sortList):
    bit=1#1表示个位
    while True:
        quit=True
        countList = [[] for i in range(10)]  #
        for item in  sortList:
            ##先得个位，逐次往高位
            try:
                countList[int(str(item)[-bit])].append(item)
                quit = False
            except:
                countList[0].append(item)
        if quit:
            ##说明不需要再继续循环了，所有得数据作再countList[0]里面
            break
        else:
            sortList=[]
            for lst in countList:
                for j in  lst:
                    sortList.append(j)
            bit += 1
        print(sortList)
    return countList[0]
sortList=[19,12,53,75,38,73,27,49,46,81,193,76,98,34,51,23,46]
print("基数排序得结果如下：")
print(radixSort(sortList))