笔面试准备（2）——常见的十大算法汇总

最新推荐文章于 2022-07-01 13:54:12 发布

芷若初荨

最新推荐文章于 2022-07-01 13:54:12 发布

阅读量407

点赞数 3

分类专栏：算法设计与分析文章标签：常见十大排序算法笔面试排序算法

本文链接：https://blog.csdn.net/cecilia620/article/details/104632703

版权

算法设计与分析专栏收录该内容

3 篇文章 0 订阅

订阅专栏

最近由于在准备春招，在刷题的同时，对于常见的基本排序算法仍然存在一些没掌握的地方，因此，再次做个简单的总结——

首先，就从汇总表开始——

在这里插入图片描述

规律小结

“不稳定”排序算法：快、些(希)、选、堆。
简单排序包括除希尔排序之外的所有冒泡排序、插入排序、简单选择排序。其中直接插入排序最简单，但当序列基本有序或者n较小时，直接插入排序是好的方法，因此常将它和其他的排序方法，如快速排序、归并排序等结合在一起使用。
**算法复杂度与序列初始状态无关（即最坏、最好以及平均复杂度都相同）**的有：选（选择排序）、基（基数）、归（归并）、堆
总的排序趟数与初始状态无关的：除了快速排序，优化后的冒泡排序，其他的排序算法都是。
元素总比较次数与初始状态无关是：选、基
元素总移动次数与初始状态无关：基、归

常见基本排序方法介绍

可以根据通过比较来决定元素间的相对次序来分成以下类型：

非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。
线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。

非线性时间的基于比较类型的排序算法(In-Place)

插入排序

插入排序包括直接插入排序和希尔排序。

直接插入排序

核心思想

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。

包括：直接插入排序，二分插入排序（又称折半插入排序），链表插入排序

在这里插入图片描述

算法复杂度分析

如果目标是把n个元素的序列升序排列，那么采用插入排序存在最好情况和最坏情况。

最好的情况就是数据已经是升序的情况，需要进行操作比较n-1次；

最坏的情况就是数据逆序排列，需要操作比较n(n-1)/2次。

注意：插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于1000，那么插入排序还是一个不错的选择。

平均时间复杂度是O(n^2), 最好情况下的时间复杂度是O(n), 最坏的情况时间复杂度是O(n^2),空间复杂度是O(1),不需要额外的空间。

代码实现

直接插入排序可以用两个循环完成：

第一层循环：遍历待比较的所有数组元素；
第二层循环：将本轮选择的元素(selected)与已经排好序的元素(ordered)相比较。
如果：selected > ordered，那么将二者交换。

def insert_sort(L):
    #遍历数组中的所有元素，其中0号索引元素默认已排序，因此从1开始
    for x in range(1,len(L)):
    #将该元素与已排序好的前序数组依次比较，如果该元素小，则交换
    #range(x-1,-1,-1):从x-1倒序循环到0
        for i in range(x-1,-1,-1):
    #判断：如果符合条件则交换
            if L[i] > L[i+1]:
                temp = L[i+1]
                L[i+1] = L[i]
                L[i] = temp

希尔排序

希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”。是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。

核心思想

将待排序数组按照增量gap进行分组，然后将每组的元素利用直接插入排序的方法进行排序；每次将gap折半减小，循环上述操作；当gap=1时，利用直接插入，完成排序。也即是说：先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录基本有序时再对全体记录进行一次直接插入排序。

注意：一般的初次取序列的一半为增量，以后每次减半，直到增量为1。（再此以gap=gap*3+1为公式）

在这里插入图片描述

算法复杂度分析

不需要大量的辅助空间，和归并排序一样容易实现。希尔排序是基于插入排序的一种算法。

希尔排序的时间的平均时间复杂度为 $O(n^{\frac{3}{2}})$ 。最好情况的时间复杂度是O(n)], 最坏起的情况时间复杂度是 $O(n^2)$ ，空间复杂度是 $O (1)$ 。

希尔排序时间复杂度的下界是n*logn。希尔排序没有快速排序算法快，因此中等大小规模表现良好，对规模非常大的数据排序不是最优选择。

注意：Shell算法的性能与所选取的分组长度序列有很大关系。执行时间依赖于增量序列。

代码实现

希尔排序的总体实现应该由三个循环完成：

第一层循环：将gap依次折半，对序列进行分组，直到gap=1;
第二、三层循环：也即直接插入排序所需要的两次循环。
- 第二层循环：遍历待比较的所有数组元素;
- 第三层循环：将本轮选择的元素(selected)与已经排好序的元素(ordered)相比较。
  如果：selected > ordered，那么将二者交换。

#希尔排序
def insert_shell(L):
    #初始化gap值，此处利用序列长度的一般为其赋值
    gap = (int)(len(L)/2)
    #第一层循环：依次改变gap值对列表进行分组
    while (gap >= 1):
    #第二层、第三层循环：利用直接插入排序的思想对分组数据进行排序
    #range(gap,len(L)):从gap开始
        for x in range(gap,len(L)):
    #range(x-gap,-1,-gap):从x-gap开始与选定元素开始倒序比较，每个比较元素之间间隔gap
            for i in range(x-gap,-1,-gap):
    #如果该组当中两个元素满足交换条件，则进行交换
                if L[i] > L[i+gap]:
                    temp = L[i+gap]
                    L[i+gap] = L[i]
                    L[i] =temp
    #while循环条件折半
        gap = (int)(gap/2)

选择排序

简单选择排序

核心思想

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

在这里插入图片描述

算法分析

复杂度分析

平均时间复杂度是 $O(n^2)$ ，最好的情况和最坏的情况下时间复杂度是 $O(n^2)$ 。空间复杂度是 $O (1)$ 。

稳定性分析

选择排序是每次都挑选最大（小）的元素放到数列的起始位置，对于重复的元素的相对位置也可能被破坏，那么该排序算法属于不稳定的算法。但是和原始数列的顺序是否有序无关，时间复杂度都是 $O(n^2)$ 。

代码实现

从待排序序列中，找到关键字最小的元素；
如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；
从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束。
因此我们可以发现，简单选择排序也是通过两层循环实现。
- 第一层循环：依次遍历序列当中的每一个元素
- 第二层循环：将遍历得到的当前元素依次与余下的元素进行比较，符合最小元素的条件，则交换。

# 简单选择排序
def select_sort(L):
#依次遍历序列中的每一个元素
    for x in range(0,len(L)):
#将当前位置的元素定义此轮循环当中的最小值
        minimum = L[x]
#将该元素与剩下的元素依次比较寻找最小元素
        for i in range(x+1,len(L)):
            if L[i] < minimum:
                temp = L[i];
                L[i] = minimum;
                minimum = temp
#将比较后得到的真正的最小值赋值给当前位置
        L[x] = minimum

堆排序

堆是一个近似完全二叉树的结构，并且子结点的键值或索引总是小于（或者大于）它的父节点。其本质是一种数组对象，根据任意的叶子节点小于（或大于）它所有的父节点的性质分成大顶堆和小顶堆，大顶堆要求节点的元素都要大于其孩子，小顶堆要求节点元素都小于其左右孩子，两者对左右孩子的大小关系不做任何要求。

核心思想

根据堆的性质进行排序。

注意：常见的排序应用在LeetCode上的TopK问题，即在一组有序的数组上寻找前K个大（小）的元素或者第k个大（小）的元素，其解决方案可见我的学习笔记（持续更新中！！！）。

使用策略：求前 k 大，用小顶堆，求前 k 小，用大顶堆。( heaq.nlargest(k, iterable, key)的方法能够直接获得最大k长度的数据，相反的nsmallest可以获得最小k长度的数据，在python的heaq包里，比较实用！)

在这里插入图片描述

算法分析

复杂度分析

平均时间复杂度、最好的情况和最坏的情况下时间复杂度都是 $O （ n l o g n)$ ，空间复杂度是 $O (1)$ 。

注意：

以插入法创建堆的时间复杂度是O（nlogn），这种方式也称为自顶向下的建堆方式。这可以帮助记忆——快（快排）些（希尔）以O（nlogn）的速度归（归并）队（堆）。
自下向上的方式创建堆的方式的时间复杂度是O(n)。
堆的插入过程也是在一个有序的堆后面插入一个元素，所以每次只需要跟它的根节点进行比较即可，最多移动的次数是logn次。
对于第k层的元素，最多需要移动的次数是k次，k层的元素一共有2^K个，那么需要移动的次数就是k*logk次数，即时间复杂度。

稳定性分析

堆排序在移动的过程中，对于重复元素的相对位置可能会被破坏，因此是不稳定的，但是堆排序与原始数列的顺序与否没有关系，时间复杂度一直都是O(nlogn)。

代码实现

堆排序可以按照以下步骤来完成：

首先将序列构建称为大顶堆（位于根节点的元素一定是当前序列的最大值）；
取出当前大顶堆的根节点，将其与序列末尾元素进行交换；
（此时：序列末尾的元素为已排序的最大值；由于交换了元素，当前位于根节点的堆并不一定满足大顶堆的性质）
对交换后的n-1个序列元素进行调整，使其满足大顶堆的性质；
重复2.3步骤，直至堆中只有1个元素为止

#**********获取左右叶子节点**********
def LEFT(i):
    return 2*i + 1
def RIGHT(i):
    return 2*i + 2
#********** 调整大顶堆 **********
#L:待调整序列 length: 序列长度 i:需要调整的结点
def adjust_max_heap(L,length,i):
#定义一个int值保存当前序列最大值的下标
    largest = i
#执行循环操作：两个任务：1 寻找最大值的下标；2.最大值与父节点交换
    while (1):
#获得序列左右叶子节点的下标
        left,right = LEFT(i),RIGHT(i)
#当左叶子节点的下标小于序列长度 并且 左叶子节点的值大于父节点时，将左叶子节点的下标赋值给largest
        if (left < length) and (L[left] > L[i]):
            largest = left
            print('左叶子节点')
        else:
            largest = i
#当右叶子节点的下标小于序列长度 并且 右叶子节点的值大于父节点时，将右叶子节点的下标值赋值给largest
        if (right < length) and (L[right] > L[largest]):
            largest = right
            print('右叶子节点')
#如果largest不等于i 说明当前的父节点不是最大值，需要交换值
        if (largest != i):
            temp = L[i]
            L[i] = L[largest]
            L[largest] = temp
            i = largest
            print(largest)
            continue
        else:
            break
#********** 建立大顶堆 **********
def build_max_heap(L):
    length = len(L)
    for x in range((int)((length-1)/2),-1,-1):
        adjust_max_heap(L,length,x)
#********** 堆排序 **********
def heap_sort(L):
#先建立大顶堆，保证最大值位于根节点；并且父节点的值大于叶子结点
    build_max_heap(L)
#i：当前堆中序列的长度.初始化为序列的长度
    i = len(L)
#执行循环：1. 每次取出堆顶元素置于序列的最后(len-1,len-2,len-3...)
#         2. 调整堆，使其继续满足大顶堆的性质，注意实时修改堆中序列的长度
    while (i > 0):
        temp = L[i-1]
        L[i-1] = L[0]
        L[0] = temp
#堆中序列长度减1
        i = i-1
#调整大顶堆
        adjust_max_heap(L,i,0)

交换排序

冒泡排序

核心思想

利用的比较交换，利用循环将第 i 小或者大的元素归位，归位操作利用的是对 n 个元素中相邻的两个进行比较，如果顺序正确就不交换，如果顺序错误就进行位置的交换。通过重复的循环访问数组，直到没有可以交换的元素，那么整个排序就已经完成了。其明显的特征是：越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列）。

在这里插入图片描述

算法分析

复杂度分析

平均时间复杂度是 $O(n^2)$ , 最好的情形是只需要遍历一次，也就是原数列基本有序，时间复杂度是O(n)，最坏的情况是O(n^2)。

稳定性分析

因为在比较的过程中，当两个相同大小的元素相邻，只比较大或者小，所以相等的时候是不会交换位置的。而当两个相等元素离着比较远的时候，也只是会把他们交换到相邻的位置。他们的位置前后关系不会发生任何变化，所以算法是稳定的。
但是经过优化后的冒泡排序和原序列顺序是否有序有关的，注意这一点！！！

代码实现

将序列当中的左右元素，依次比较，保证右边的元素始终大于左边的元素；
（第一轮结束后，序列最后一个元素一定是当前序列的最大值；）
对序列当中剩下的n-1个元素再次执行步骤1。
对于长度为n的序列，一共需要执行n-1轮比较
（利用while循环可以减少执行次数）

#冒泡排序
def bubble_sort(L):
    length = len(L)
#序列长度为length，需要执行length-1轮交换
    for x in range(1,length):
#对于每一轮交换，都将序列当中的左右元素进行比较
#每轮交换当中，由于序列最后的元素一定是最大的，因此每轮循环到序列未排序的位置即可
        for i in range(0,length-x):
            if L[i] > L[i+1]:
                temp = L[i]
                L[i] = L[i+1]
                L[i+1] = temp

快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。

核心思想

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

在这里插入图片描述

算法分析

复杂度分析

最好情况（待排序列接近无序）时间复杂度为O(nlogn)，最坏情况（待排序列接近有序）时间复杂度为O(n^2)，平均时间复杂度为O(nlogn)。

稳定性分析

不稳定性排序。

代码实现

基本思想：挖坑填数+分治法

从序列当中选择一个基准数(pivot)
在这里我们选择序列当中第一个数最为基准数
将序列当中的所有数依次遍历，比基准数大的位于其右侧，比基准数小的位于其左侧
重复步骤1.2，直到所有子集当中只有一个元素为止。
- 描述如下：
  1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
  2．j–由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
  3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
  4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中

#快速排序
#L：待排序的序列；start排序的开始index,end序列末尾的index
#对于长度为length的序列：start = 0;end = length-1
def quick_sort(L,start,end):
    if start < end:
        i , j , pivot = start , end , L[start]
        while i < j:
#从右开始向左寻找第一个小于pivot的值
            while (i < j) and (L[j] >= pivot):
                j = j-1
#将小于pivot的值移到左边
            if (i < j):
                L[i] = L[j]
                i = i+1 
#从左开始向右寻找第一个大于pivot的值
            while (i < j) and (L[i] < pivot):
                i = i+1
#将大于pivot的值移到右边
            if (i < j):
                L[j] = L[i]
                j = j-1
#循环结束后，说明 i=j，此时左边的值全都小于pivot,右边的值全都大于pivot
#pivot的位置移动正确，那么此时只需对左右两侧的序列调用此函数进一步排序即可
#递归调用函数：依次对左侧序列：从0 ~ i-1//右侧序列：从i+1 ~ end
        L[i] = pivot
#左侧序列继续排序
        quick_sort(L,start,i-1)
#右侧序列继续排序
        quick_sort(L,i+1,end)

归并排序

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各解"修补"在一起，即分而治之)。

在这里插入图片描述

可以看到这种结构很像一棵完全二叉树，本次的归并排序是采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为logn。
注意：

归并排序可以适用于大文件类型的排序，如果出现内存不足的情况，比较适合。
缺点是Out-place sort，因此相比快排，需要很多额外的空间。
为什么归并排序比快速排序慢？答：虽然渐近复杂度一样，但是归并排序的系数比快排大。
对于归并排序有什么改进？答：就是在数组长度为k时，用插入排序，因为插入排序适合对小数组排序。复杂度为O(nk+nlg(n/k))，当k=O(lgn)时，复杂度为O(nlgn)。

核心思想

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。
即：左半边用尽，则取右半边元素；右半边用尽，则取左半边元素；右半边的当前元素小于左半边的当前元素，则取右半边元素；右半边的当前元素大于左半边的当前元素，则取左半边的元素。

在这里插入图片描述

算法分析

复杂度分析

最好的情况、最坏的情况、平均的时间复杂度都是O(nlogn)。

稳定性分析

归并排序对于重复的数据不会交换位置，因此不会破坏元素的相对位置，即属于稳定性的算法。

代码实现

归并排序其实要做两件事：

分解----将序列每次折半拆分
合并----将划分后的序列段两两排序合并
因此，归并排序实际上就是两个操作，拆分+合并
如何合并？
- L[first…mid]为第一段，L[mid+1…last]为第二段，并且两端已经有序，现在我们要将两端合成达到L[first…last]并且也有序。
- 首先依次从第一段与第二段中取出元素比较，将较小的元素赋值给temp[]
- 重复执行上一步，当某一段赋值结束，则将另一段剩下的元素赋值给temp[]
- 此时将temp[]中的元素复制给L[]，则得到的L[first…last]有序
  -** 如何分解？**
- 在这里，我们采用递归的方法，首先将待排序列分成A,B两组；然后重复对A、B序列
  分组；直到分组后组内只有一个元素，此时我们认为组内所有元素有序，则分组结束。

# 归并排序
# merge function
# 将序列L[first...mid]与序列L[mid+1...last]进行合并
def mergearray(L,first,mid,last,temp):
#对i,j,k分别进行赋值
    i,j,k = first,mid+1,0
#当左右两边都有数时进行比较，取较小的数
    while (i <= mid) and (j <= last):
        if L[i] <= L[j]:
            temp[k] = L[i]
            i = i+1
            k = k+1
        else:
            temp[k] = L[j]
            j = j+1
            k = k+1
#如果左边序列还有数
    while (i <= mid):
        temp[k] = L[i]
        i = i+1
        k = k+1
#如果右边序列还有数
    while (j <= last):
        temp[k] = L[j]
        j = j+1
        k = k+1
#将temp当中该段有序元素赋值给L待排序列使之部分有序
    for x in range(0,k):
        L[first+x] = temp[x]
# partition function
def merge_sort(L,first,last,temp):
    if first < last:
        mid = (int)((first + last) / 2)
#使左边序列有序
        merge_sort(L,first,mid,temp)
#使右边序列有序
        merge_sort(L,mid+1,last,temp)
#将两个有序序列合并
        mergearray(L,first,mid,last,temp)
        
# 归并排序的函数
def merge_sort_array(L):
#声明一个长度为len(L)的空列表
    temp = len(L)*[None]
#调用归并排序
    merge_sort(L,0,len(L)-1,temp)

线性时间的非比较型的排序算法(Out-Place)

计数排序

计数排序是一个非基于比较的排序算法，其优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)（其中k是整数的范围)，快于任何比较排序算法。这是一种用空间换取时间的做法，而且当O(k)>O(n*log(n))的时候其效率反而不如基于比较的排序（基于比较的排序的时间复杂度在理论上的下限是O(n*log(n)), 如归并排序，堆排序）

核心思想

将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

算法分析

复杂度分析

最好、最坏以及平均时间复杂度是O(n+K)。空间复杂度是O(K)。

稳定性分析

属于稳定性算法。

代码实现

找出待排序的数组中最大max和最小min的元素；
统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)-1。

# 计数排序
def counting_sort(a):
     n = len(a) # 数组长度
     result = [None]*n # 开辟同长度的数组，用于存储排序后的数组
     for i in range(n):
          p=0
          q=0
          for j in range(n):
               if a[j]<a[i]:
                    p+=1
               elif a[j]==a[i]:
                    q+=1
          for k in range(p,p+q):
               result[k]=a[i]
     return result

桶排序

根据百度百科上描述，桶排序 (Bucket sort)或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是比较排序，他不受到 O(n log n) 下限的影响。

核心思想

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
其应用最常见的就是对于一个有序的数组，从中找出出现频率最多为K的元素或者根据出现的频率进行排序的问题。算法问题可见LeetCode347-top-k-frequent-elements和LeetCode451-sort-characters-by-frequency。实现思路可参考我的github。

在这里插入图片描述

算法分析

复杂度分析

最好的情况(当输入的数据可以均匀的分配到每一个桶中)和平均时间复杂度是O(n+K), 最坏的情况(当输入的数据被分配到了同一个桶中)的时间复杂度是O(n^2), 空间复杂度是O(n+K)。

稳定性分析

属于稳定性算法。

代码实现

设置一个定量的数组当作空桶；
遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶进行排序；
从不是空的桶里把排好序的数据拼接起来。

def bucket_sort(s):    
    """桶排序"""    
    min_num = min(s)    
    max_num = max(s)    
    # 桶的大小    
    bucket_range = (max_num-min_num) / len(s)    
    # 桶数组    
    count_list = [ [] for i in range(len(s) + 1)]    
    # 向桶数组填数    
    for i in s:        
        count_list[int((i-min_num)//bucket_range)].append(i)    
    s.clear()    
    # 回填，这里桶内部排序直接调用了sorted    
    for i in count_list:        
        for j in sorted(i):            
            s.append(j)

基数排序

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）。

核心思想

通过序列中各个元素的值，对排序的N个元素进行若干趟的“分配”与“收集”来实现排序。
也就是说——基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

在这里插入图片描述

算法分析

复杂度分析

设待排序列为n个记录，K个关键码，关键码的取值范围长度为r，则进行链式基数排序的时间复杂度为O(d(n+r))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。空间复杂度，需要2r个指向队列的辅助空间，以及用于静态链表的n个指针。
总体可以描述为：最好、最坏、平均的时间复杂度为O(n*K)，空间复杂度为O(n+K)。

稳定性分析

属于稳定性算法。

代码实现

分配：我们将L[i]中的元素取出，首先确定其个位上的数字，根据该数字分配到与之序号相同的桶中；
收集：当序列中所有的元素都分配到对应的桶中，再按照顺序依次将桶中的元素收集形成新的一个待排序列L[ ]；
对新形成的序列L[]重复执行分配和收集元素中的十位、百位…直到分配完该序列中的最高位，则排序结束；

#确定排序的次数
#排序的顺序跟序列中最大数的位数相关
def radix_sort_nums(L):
    maxNum = L[0]
#寻找序列中的最大数
    for x in L:
        if maxNum < x:
            maxNum = x
#确定序列中的最大元素的位数
    times = 0
    while (maxNum > 0):
        maxNum = (int)(maxNum/10)
        times = times+1
    return times
#找到num从低到高第pos位的数据
def get_num_pos(num,pos):
    return ((int)(num/(10**(pos-1))))%10
#基数排序
def radix_sort(L):
    count = 10*[None]       #存放各个桶的数据统计个数
    bucket = len(L)*[None]  #暂时存放排序结果
#从低位到高位依次执行循环
    for pos in range(1,radix_sort_nums(L)+1):
        #置空各个桶的数据统计
        for x in range(0,10):
            count[x] = 0
        #统计当前该位(个位，十位，百位....)的元素数目
        for x in range(0,len(L)):
            #统计各个桶将要装进去的元素个数
            j = get_num_pos(int(L[x]),pos)
            count[j] = count[j]+1
        #count[i]表示第i个桶的右边界索引
        for x in range(1,10):
            count[x] = count[x] + count[x-1]
        #将数据依次装入桶中
        for x in range(len(L)-1,-1,-1):
            #求出元素第K位的数字
            j = get_num_pos(L[x],pos)
            #放入对应的桶中，count[j]-1是第j个桶的右边界索引
            bucket[count[j]-1] = L[x]
            #对应桶的装入数据索引-1
            count[j] = count[j]-1
        # 将已分配好的桶中数据再倒出来，此时已是对应当前位数有序的表
        for x in range(0,len(L)):
            L[x] = bucket[x]

PS：上述动图感谢由五分钟学算法提供！