十大经典排序算法（动图演示）

最新推荐文章于 2024-05-25 15:32:40 发布

snowdroptulip

最新推荐文章于 2024-05-25 15:32:40 发布

阅读量1.1k

点赞数 1

分类专栏：算法

本文链接：https://blog.csdn.net/snowdroptulip/article/details/108622218

版权

算法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

感谢原文作者：https://www.cnblogs.com/onepixel/articles/7674659.html
本文基本框架、文字、图片基本主要来自原文，原中是用java实现的，这里我把代码全部用python做了实现，内容也做了一些补充。

0、算法概述

0.1 算法分类

十种常见排序算法可以分为两大类：

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

0.2 算法复杂度

在这里插入图片描述

0.3 相关概念

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b
的后面。
时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

1、冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

比较相邻的元素。如果第一个比第二个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。

1.2 动图演示

在这里插入图片描述

1.3 python代码实现

def bubbleSort(arr):
    n = len(arr)
    # 遍历所有数组元素
    for i in range(n):
        # Last i elements are already in place
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

1.4 最优时间复杂度

当原序列已经是排序好的序列，此时需要引入一个额外的变量sorted_flag，每执行一迭代，判断是否发生了元素的交换，如果没有交换，则无需再进行下一次排序，所有最优时间复杂度是O(n)

def bubbleSort(arr):
    n = len(arr)

    # 遍历所有数组元素
    for i in range(n):
        # Last i elements are already in place
        sorted_flag = True
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                sorted_flag = False
                
        if sorted_flag:
            break
    return arr

2、选择排序（Selection Sort）

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1…n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。

2.2 动图演示

在这里插入图片描述

2.3 python代码实现

def selectionSort(arr):
    n = len(arr)
    for i in range(n-1):
        minIndex = i
        minNum = arr[i]
        for j in range(i+1,n):
            if arr[j]<minNum:
                minIndex = j
                minNum = arr[j]
        arr[i],arr[minIndex]= arr[minIndex],arr[i]

    return arr

2.4 最优时间复杂度

选择排序的最优时间复杂度是 $O(n^2)$ ，因为每一次迭代都需要在后面的元素中找最小值，即使序列已经是正序序列，也需要遍历完后面的每一个元素。

3、插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；重复步骤2~5。

3.2 动图演示

在这里插入图片描述

3.3 python代码实现

def insertionSort(arr):
    n = len(arr)
    for i in range(1,n):
        j = i
        while j >= 1:
            if arr[j]<arr[j-1]:
                arr[j],arr[j-1]=arr[j-1],arr[j]
            else:
                break
            j-=1
    return arr

3.4 最优时间复杂度

该算法的最优时间复杂度是O(n)。如果序列是正序排序的序列，那么每一次迭代只需要比较一次，break跳出当前迭代比较即可，所以总共只需要比较n-1次。

4、希尔排序（Shell Sort）

1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

4.1 算法描述

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

更详细的解释请参考：https://blog.csdn.net/qq_39207948/article/details/80006224

4.2 动图演示

在这里插入图片描述

4.3 python代码实现

def shellSort(arr):

    n = len(arr)
    gap = int(n / 2)

    while gap > 0: # 对每个gap进行排序，每个gap对应对个需要排序的组
        for i in range(gap): # 对每组进行插入排序
            j = i+gap # 此时当数组index=j一定存在
            while j < n:
                k = j
                while k > i:# 插入排序单个元素
                    if arr[k]<arr[k-gap]:
                        arr[k], arr[k - gap] = arr[k - gap], arr[k]
                    else:
                        break
                    k-=gap
                j+=gap


        gap = int(gap/2)

    return arr

4.4 最优时间复杂度

希尔算法是插入算法的升级版，我们知道当一个序列越接近正序排序，插入算法的时间复杂度越低，希尔算法的目的就是使得序列越来越接近正序排序，从而降低时间复杂度。

5、归并排序（Merge Sort）

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

5.1 算法描述

把长度为n的输入序列分成两个长度为n/2的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列。

5.2 动图演示

在这里插入图片描述

5.3 python代码实现

def mergeSort(arr):

    def merge(arr1,arr2):# 归并两个有序序列
        sorted_arr = []
        i1,i2 = 0,0
        n1,n2 = len(arr1),len(arr2)
        while i1 < n1 and i2 < n2:
            if arr1[i1]<arr2[i2]:
                sorted_arr.append(arr1[i1])
                i1+=1
            else:
                sorted_arr.append(arr2[i2])
                i2+=1
        if i1<n1:
            sorted_arr = sorted_arr+arr1[i1:]
        if i2<n2:
            sorted_arr = sorted_arr + arr2[i2:]
        return sorted_arr

    n = len(arr)
    step = 1
    while step < n:
        i = 0
        while i < n:

            if i+step>=n:# 如果第二个序列不存在
                break

            arr[i:i+step*2]=merge(arr[i:i+step],arr[i+step:i+step*2])
            i = i+step*2
        step*=2
    return arr

5.4 归并排序时间复杂度

下面我要讲归并排序的时间复杂度了，归并排序其实就像一颗二叉树：
在这里插入图片描述
对于一个具有n个节点的二叉树来说，它的树深为 $log_2(n+1)$ ，具体原理参考：https://blog.csdn.net/snowdroptulip/article/details/108651219
每一层排序都需要n次，所以时间复杂度为 $O(nlog_2n)$

6、快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

6.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

6.2 动图演示

在这里插入图片描述

6.3 python代码实现

def quick_sort(arr, start, end):

    if start >= end:
        return
    mid = arr[start]
    low = start
    high = end

    while low < high:

        while low < high and arr[high] >= mid:
            high -= 1
        arr[low] = arr[high]

        while low < high and arr[low] < mid:
            low += 1
        arr[high] = arr[low]

    arr[low] = mid

    quick_sort(arr, start, low - 1)
    quick_sort(arr, low + 1, end)

6.4 快速排序时间复杂度

快速排序的时间复杂度与归并排序的时间复杂度一致，可参考5.4

7、堆排序（Heap Sort）

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

7.1 算法描述

将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

详细算法描述请参考：
https://www.cnblogs.com/chengxiao/p/6129630.html
https://www.cnblogs.com/jingmoxukong/p/4303826.html

7.2 动图演示

在这里插入图片描述

8、计数排序（Counting Sort）

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

8.1 算法描述

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

8.2 动图演示

9、桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

9.1 算法描述

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

9.2 图片演示

在这里插入图片描述

10、基数排序（Radix Sort）

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

10.1 算法描述

取得数组中的最大数，并取得位数；
arr为原始数组，从最低位开始取每个位组成radix数组；
对radix进行计数排序（利用计数排序适用于小范围数的特点）；

10.2 动图演示

在这里插入图片描述

参考文献

https://www.cnblogs.com/onepixel/articles/7674659.html
希尔排序–简单易懂图解
 https://www.cnblogs.com/chengxiao/p/6129630.html
https://www.cnblogs.com/jingmoxukong/p/4303826.html

snowdroptulip

关注

1
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
十大经典排序算法（动图演示）

感谢原文作者：https://www.cnblogs.com/onepixel/articles/7674659.html本文基本框架、文字、图片基本主要来自原文，原中是用java实现的，这里我把代码全部用python做了实现，内容也做了一些补充。0、算法概述0.1 算法分类十种常见排序算法可以分为两大类：比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的
复制链接

扫一扫

专栏目录