Python实现所有的排序

最新推荐文章于 2024-06-12 08:53:02 发布

CATs_001

最新推荐文章于 2024-06-12 08:53:02 发布

阅读量403

点赞数 1

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

本文链接：https://blog.csdn.net/happyxghero/article/details/108837388

版权

算法专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一、冒泡排序

一句话总结：每轮遍历两两比较，顺序错误就交换，每轮把最小/最大的数放到数组最后的位置。

def BubbleSort(listArray):
    n = len(listArray)
    for i in range(n):
        for j in range(1, n - i):
            if listArray[j] < listArray[j - 1]:
                listArray[j - 1], listArray[j] = listArray[j], listArray[j - 1]
    return listArray

【多说两句】

冒泡排序可以提速，在内循环中设置标记，如果在一轮排序中没有发现数据的交换，则可以立即返回；
冒泡排序最好的情况就是数据本身有序，最坏的情况是数据本身是逆序的

二、选择排序

一句话总结：每轮遍历选择最大\最小的记录其下标，遍历完成后和当前遍历初始位置交换。

def SelectSort(listArray):
    n = len(listArray)
    for i in range(n):
        index = i
        for j in range(i, n):
            if listArray[j] < listArray[index]:
                index = j
        listArray[i], listArray[index] = listArray[index], listArray[i]
    return listArray

三、插入排序

一句话总结：把前部分看成是已经排好序的，以后的每一个数依次取出插入到前面，直到所有的数都排好序。

def InsertSort(listArray):
    n = len(listArray)
    for i in range(n - 1):
        for j in range(i + 1, 0, -1):
            if listArray[j] < listArray[j - 1]:
                listArray[j], listArray[j - 1] = listArray[j - 1], listArray[j]
    return listArray

四、归并排序

一句话总结：先分后并，利用递归

def MergeSort(listArray):
    n = len(listArray)
    if n <= 1:
        return listArray
    num = int(n / 2)
    left = MergeSort(listArray[:num])
    right = MergeSort(listArray[num:])
    return Merge(left, right)

def Merge(left, right):
    l,r = 0, 0
    result = []
    while l < len(left) and r < len(right):
        if left[l] > right[r]:
            result.append(right[r])
            r += 1
        else:
            result.append(left[l])
            l += 1
    result += left[l:]
    result += right[r:]
    return result

【多说两句】

如何计算归并排序的时间复杂度？

master公式： $T(N) = aT(\frac{n}{b}) + O(N^{d})$

若 $\log_ba > d$ ，则时间复杂度为 $O(N^{\log _ba})$ ；

若 $\log_ba = d$ ，则时间复杂度为 $O(N^{d\log N})$ ；

若 $\log_ba < d$ ，则时间复杂度为 O(N^d) ；

其中：

T(N)是数据规模为N的情况下时间复杂度

a是递归的次数、b是递归的规模

请记住，任何递归写法均可用非递归代替，递归是系统帮你压栈，会将很多多余的信息保存起来，会造成比较大的成本开销，一般在工业上很少使用递归的代码。

递归转化成非递归的一般方法

五、快速排序

一句话总结：选一个基准值，大的放右边，小的放左边，递归进行

def QuickSort(listArray):
    return Qsort(listArray,0,len(listArray)-1)

def Qsort(listArray, left, right):
    if left >= right:
        return listArray
    key = listArray[left]
    lp = left
    rp = right
    while lp < rp :
        while listArray[rp] >= key and lp < rp :
            rp -= 1
        while listArray[lp] <= key and lp < rp :
            lp += 1
        listArray[lp], listArray[rp] = listArray[rp], listArray[lp]
    listArray[left], listArray[lp] = listArray[lp], listArray[left]
    Qsort(listArray, left, lp - 1)
    Qsort(listArray, rp + 1, right)
    return listArray