python排序算法可视化 代码_排序算法总结（Python实现代码）

注：本文主要目的是总结网上的资料，方便自己复习，非原创，参考链接见文末。

冒泡排序

算法描述

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

算法分析

• 最佳情况：T(n) = O(n)
• 最差情况：T(n) = O(n2)
• 平均情况：T(n) = O(n2)

def 

---

选择排序

算法描述：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

算法分析：

• 最佳情况：T(n) = O(n2)
• 最差情况：T(n) = O(n2)
• 平均情况：T(n) = O(n2)

def 

---

插入排序

算法描述：

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

算法分析：

• 最佳情况：T(n) = O(n)
• 最坏情况：T(n) = O(n2)
• 平均情况：T(n) = O(n2)

def 

---

希尔排序

算法描述：

希尔排序是插入排序的高效实现，将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序。

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

算法分析：

• 最佳情况：T(n) = O(nlog2 n)
• 最坏情况：T(n) = O(nlog2 n)
• 平均情况：T(n) =O(nlog2n)

def 

---

归并排序

算法描述：

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。

归并排序使用了分治法的思想。

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

算法分析：

• 最佳情况：T(n) = O(n)
• 最差情况：T(n) = O(nlogn)
• 平均情况：T(n) = O(nlogn)

def 

---

快速排序

算法描述：

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

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

算法分析：

• 最佳情况：T(n) = O(nlogn)
• 最差情况：T(n) = O(n2)
• 平均情况：T(n) = O(nlogn)

看了一些博客的代码和GIF图，会出现GIF图跟代码不匹配的情况（我第一次看也很懵）。实际上快排算法是有不同的实现方式的。其基本思想是使用两个指针来遍历待排序的数组，根据两个指针遍历的方向可以分为两类：第一，两个指针从待排序数组的同一个方向遍历。第二，两个指针分别从待排序数组的两端进行遍历。

从同一方向遍历时的状态。在循环中，low指向的是小于枢纽的那部分元素的最右端，high在未排序的部分遍历。循环直到high指针到达right的位置（数组的最右端），如下图第二个图所示。此时数组除了枢纽pivot被划分为两部分：小于pivot的和大于等于pivot的。然后将low和枢纽元素交换就可以得到本次排序的第一趟结果：

def 

当从两个方向分别遍历数组时，下图是遍历的循环过程状态。循环时，low向右移动，high向左移动。

def 

---

堆排序

算法描述：

利用堆这种数据结构而设计的一种排序算法。

堆是具有以下性质的完全二叉树：

大顶堆：每个结点的值都大于或等于其左右孩子结点的值

小顶堆：每个结点的值都小于或等于其左右孩子结点的值

堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

基本步骤：

• 将无序数组构建成堆，根据升序降序需求选择大顶堆小顶堆
• 将堆顶元素与末尾元素交换，将最大/最小元素放在数组末尾
• 调整结构满足堆定义
• 综上，反复执行调整堆结构和交换元素的步骤。

算法分析：

堆排序的初始建堆过程比价复杂，对O(n)级别个非叶子节点进行堆调整操作O(logn)，时间复杂度O(nlogn)；之后每一次堆调整操作确定一个数的次序，时间复杂度O(nlogn)。合起来时间复杂度O(nlogn)。

• 最佳情况：T(n) = O(nlogn)
• 最差情况：T(n) = O(nlogn)
• 平均情况：T(n) = O(nlogn)

图解堆排序：图解排序算法(三)之堆排序 - dreamcatcher-cx - 博客园

def heapSort(array):
    def heapAdjust(array,root,end):
        # 将以root为根节点的堆调整为大顶堆
        temp=array[root]
        son=2*root+1
        while son<=end:
            if son<end and array[son]<array[son+1]: ##找出左右孩子节点较大的
                son+=1
            if temp>=array[son]: #r 如果是大顶堆，打破循环
                break
            array[root]=array[son] # 交换元素之后继续向下调整
            root=son
            son=2*son+1
        array[root]=temp #将原堆顶插入正确位置

    n=len(array)
    if n<=1:
        return array
    # 建立大顶堆
    root=n//2-1 # 完全二叉树中最后一个非叶子节点
    while root>=0:
        heapAdjust(array,root,n-1)
        root-=1
    # 将堆顶元素和数组最后一个元素交换，再调整堆结构
    i=n-1
    while i>=0:
        array[0],array[i]=array[i],array[0] # 堆顶放在数组末
        heapAdjust(array,0,i-1) # 调整剩余元素
        i-=1
    return array

排序算法总结

• 稳定 ：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
• 不稳定 ：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
• 内排序 ：所有排序操作都在内存中完成；
• 外排序 ：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
• 时间复杂度 ： 一个算法执行所耗费的时间。
• 空间复杂度 ：运行完一个程序所需内存的大小。

参考资料

史上最简单十大排序算法（Python实现）_白糖炒栗子-CSDN博客

超详细十大经典排序算法总结（java代码）c或者cpp的也可以明白_Top_Spirit的博客-CSDN博客