python基础--十大排序算法

最新推荐文章于 2023-09-27 20:53:10 发布

置顶望长安于日下

最新推荐文章于 2023-09-27 20:53:10 发布

阅读量361

点赞数

分类专栏： python 文章标签：数据结构算法排序算法

本文链接：https://blog.csdn.net/qq_26884501/article/details/114108670

版权

python 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

排序算法一览表

在这里插入图片描述

1、冒泡排序

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

1.1、算法描述

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

1.2、动图演示
在这里插入图片描述

1.3、代码实现

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 25 11:51:10 2021

@author: daicong
"""
"""
排序思想：
一次过程：两两对比，找到最大值，放到最后面
n次过程：因为有n个元素，所以要放n次
"""
class Solution:
    def bubble_sort(self,nums):
        n =len(nums)
        for i in range(n):
            """外层循环表示已经排好了几次最大元素"""
            for j in range(n-i-1):
            	"""内层循环表示两两对比找最大"""
                if nums[j] > nums[j+1]:
                    nums[j],nums[j+1] = nums[j+1],nums[j]
        return nums

solution = Solution()
nums = [54,26,93,17,77,31,44,55,20]
res=solution.bubble_sort(nums)
print(res)

"""
[17, 20, 26, 31, 44, 54, 55, 77, 93]
"""

优化后的版本

class Solution:
    def bubble_sort(nums):
        for i in range(len(nums) - 1):  
            flag = False  # 改进后的冒泡，设置一个交换标志位
            for j in range(len(nums) - i - 1):  
                if nums[j] > nums[j + 1]:
                    nums[j], nums[j + 1] = nums[j + 1], nums[j]
                    """如果一次都没有交换，那么说明里面的都是有顺序的，此时falg的状态就不会改变，falg=False，省略了里面的排序过程"""
                    flag = True
            if not flag:
                return nums  # 这里代表计算机偷懒成功。

1.4、算法分析

最优时间复杂度：O(n) （表示遍历一次发现没有任何可以交换的元素，排序结束。）
最坏时间复杂度：O(n2)
稳定性：稳定

2、选择排序

表现最稳定的排序算法之一，因为什么数据进去都是O(n^2）的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间，理论上讲，选择排序可能也是平时排序一般人想到最多的排序方法。

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

2.1、算法描述

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

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

2.2、动态演示
在这里插入图片描述

2.3、代码实现

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 25 12:47:11 2021

@author: daicong
"""
"""
排序思想：
每次在未排序的元素中找出最小的值，与未排序的首位元素交换位置
"""

class Solution:
    def select_sort(self,nums):
        n = len(nums)
        for i in range(n):
            """外层循环表示已经排序的元素"""
            min_index=i
            for j in range(i,n):
                """内层循环表示从未排序的元素中找到最小值"""
                if nums[j] < nums[min_index]:
                    min_index = j
            """与未排序的首位元素交换位置"""
            nums[i],nums[min_index] = nums[min_index],nums[i]
        return nums

solution = Solution()
nums = [20, 54, 26, 31, 17, 44, 77, 93, 55]
res=solution.select_sort(nums)
print(res)               

"""
[17, 20, 26, 31, 44, 54, 55, 77, 93]
"""

2.4、算法分析
最佳情况：T(n)=O(n ^2)
最差情况：T(n)=O(n^2)
平均情况：T(n)=O(n^2)
稳定性：不稳定（考虑升序每次选择最大的情况）

3、插入排序

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额为空间排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

3.1、算法描述

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

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

3.2、动画演示
在这里插入图片描述
3.3、代码实现

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 25 13:40:29 2021

@author: daicong
"""
class Solution:
    def insert_sort(self,nums):
        n = len(nums)
        for i in range(1,n):
            for j in range(i,0,-1):
                """
                与前一个元素比较，如果比前一个小，则交换位置
                需要注意的是，j的最小取值，应该是列表的第一的元素，故j-1最小为0，所以上面j的range最小是1(左闭右开取不到0)
                """
                if nums[j] < nums[j-1]:
                    nums[j-1],nums[j] = nums[j],nums[j-1]
        return nums

solution = Solution()
nums = [20, 54, 26, 31, 17, 44, 77, 93, 55]
res=solution.insert_sort(nums)
print(res)

"""
[17, 20, 26, 31, 44, 54, 55, 77, 93]
"""

3.4、算法分析

最佳情况：T(n)=O(n)
最坏情况T(n)=O(n^2)
平均情况T(n)=O(n^2)
稳定性：稳定

4、希尔排序

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n^2)的第一批算法之一。它与插入排序的不同指出在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

4.1、算法描述

我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但起始这个增量序列不是最优的。此处我们做示例使用希尔增量。

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

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

4.2、过程演示
在这里插入图片描述
4.3、代码实现

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 25 14:30:40 2021

@author: daicong
"""

class Solution:
    def shell_sort(self,nums):
        n = len(nums)
        """首先第一次分组，组数为gap"""
        gap = n // 2
        
        while gap > 0:
            """对每一组的元素进行插入排序"""
            for i in range(gap, n):
                for j in range(i, gap-1, -gap):
                    """j最小为gap，nums[j-gap]=nums[0]刚好是第一个元素，解释同插入排序"""
                    if nums[j] < nums[j-gap]:
                        nums[j-gap],nums[j] = nums[j],nums[j-gap]
            gap = gap // 2
        return nums
    
solution = Solution()
nums = [20, 54, 26, 31, 17, 44, 77, 93, 55]
res=solution.shell_sort(nums)
print(res)

""""
[17, 20, 26, 31, 44, 54, 55, 77, 93]
"""

4.4、算法分析

最佳情况：T(n) = O(nlog2 n)
最坏情况：T(n) = O(nlog2 n)
平均情况：T(n) =O(nlog2n)　
稳定性：不稳定

5、归并排序

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

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

5.1、算法描述

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

5.2、动图演示

在这里插入图片描述

5.3、代码实现

# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
"""
Created on Mon Mar  1 11:07:40 2021

@author: daicong
"""

class Solution:
    def mergeSort(self,nums):
        #分解
        n= len(nums)
        if n <= 1:
            """如果剩下一个数，那么就不分解了"""
            return nums
        mid = n//2
        left = self.mergeSort(nums[0:mid])
        right = self.mergeSort(nums[mid:])
        
        #合并
        result = []
        left_pointer,right_pointer = 0,0
        """左右列表个设置一个指针，分别对左右的列表中的元素进行对比排序，然后加入到result中"""
        while left_pointer < len(left) and right_pointer < len(right):
            if left[left_pointer] < right[right_pointer]:
                """如果小的话，就直接放到result中"""
                result.append(left[left_pointer])
                left_pointer +=1
            else:
                result.append(right[right_pointer])
                right_pointer +=1
        """将两个列表中剩余的元素加进来"""
        #result.extend([left_pointer:])
        result += left[left_pointer:]
        result += right[right_pointer:]
        
        return result
            

solution = Solution()
nums = [54,26,93,17,77,31,44,55]
res=solution.mergeSort(nums)
print(res)

"""
[17, 26, 31, 44, 54, 55, 77, 93]
"""

"""拆分过程"""
[54,26,93,17,77,31,44,55]
[54,26,93,17] [77,31,44,55]
[54,26] [93,17] [77,31] [44,55]
[54] [26] [93] [17] [77] [31] [44] [55] 

"""排序合并过程"""
[54] [26] [93] [17] [77] [31] [44] [55] 
[26,54] [17,93] [31,77] [44,55]
[17,26,54,93] [31,44,55,77]
[17, 26, 31, 44, 54, 55, 77, 93]

5.4、算法分析

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

6、快速排序

快速排序（Quick Sort）是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。

快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了。虽然 Worst Case 的时间复杂度达到了 O(n²)，但是人家就是优秀，在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好。

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

6.1、算法描述

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

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

6.2、动图演示
在这里插入图片描述
6.3、代码实现

def quick_sort(alist, start, end):
    """快速排序"""

    # 递归的退出条件
    if start >= end:
        return

    # 设定起始元素为要寻找位置的基准元素
    mid = alist[start]

    # low为序列左边的由左向右移动的游标
    low = start

    # high为序列右边的由右向左移动的游标
    high = end

    while low < high:
        # 如果low与high未重合，high指向的元素不比基准元素小，则high向左移动
        """这里只需要有一边有个等于号，就可以解决边界问题,比如[54，54，60，54，54] mid=54"""
        while low < high and alist[high] >= mid:
            high -= 1
        # 将high指向的元素放到low的位置上
        alist[low] = alist[high]

        # 如果low与high未重合，low指向的元素比基准元素小，则low向右移动
        while low < high and alist[low] < mid:
            low += 1
        # 将low指向的元素放到high的位置上
        alist[high] = alist[low]

    # 退出循环后，low与high重合，此时所指位置为基准元素的正确位置
    # 将基准元素放到该位置
    alist[low] = mid

    # 对基准元素左边的子序列进行快速排序
    quick_sort(alist, start, low-1)

    # 对基准元素右边的子序列进行快速排序
    quick_sort(alist, low+1, end)


alist = [54,26,93,17,77,31,44,55,20]
quick_sort(alist,0,len(alist)-1)
print(alist)

"""
[17, 20, 26, 31, 44, 54, 55, 77, 93]
"""

6.4、算法分析
快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

7、堆排序

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

大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

7.1、算法描述

将待排序序列构建成一个堆 H[0……n-1]，根据（升序降序需求）选择大顶堆或小顶堆；
把堆首（最大值）和堆尾互换；
把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
重复步骤 2，直到堆的尺寸为 1。

7.2、动图演示
在这里插入图片描述
7.3、代码实现

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 25 15:27:46 2021

@author: daicong
"""
class Solution: 
    def buildMaxHeap(self,arr):
        import math
        for i in range(math.floor(len(arr)/2),-1,-1):
            self.heapify(arr,i)
    
    def heapify(self,arr, i):
        left = 2*i+1
        right = 2*i+2
        largest = i
        if left < arrLen and arr[left] > arr[largest]:
            largest = left
        if right < arrLen and arr[right] > arr[largest]:
            largest = right
    
        if largest != i:
            self.swap(arr, i, largest)
            self.heapify(arr, largest)
    
    def swap(self,arr, i, j):
        arr[i], arr[j] = arr[j], arr[i]
    
    def heapSort(self,arr):
        global arrLen
        arrLen = len(arr)
        self.buildMaxHeap(arr)
        for i in range(len(arr)-1,0,-1):
            self.swap(arr,0,i)
            arrLen -=1
            self.heapify(arr, 0)
        return arr
        
solution = Solution()
nums = [20, 54, 26, 31, 17, 44, 77, 93, 55]
res = solution.heapSort(nums)
print(res)

"""
[17, 20, 26, 31, 44, 54, 55, 77, 93]
"""

7.4、算法分析
堆排序的平均时间复杂度为 Ο(nlogn)

8、计数排序

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

计数排序是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中的值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

8.1、算法描述

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

8.2、动图演示
在这里插入图片描述
8.3、代码实现

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 25 15:40:10 2021

@author: daicong
"""

class Solution:
    def countingSort(self, arr, maxValue):
        bucketLen = maxValue+1
        bucket = [0]*bucketLen
        sortedIndex =0
        arrLen = len(arr)
        for i in range(arrLen):
            if not bucket[arr[i]]:
                bucket[arr[i]]=0
            bucket[arr[i]]+=1
        for j in range(bucketLen):
            while bucket[j]>0:
                arr[sortedIndex] = j
                sortedIndex+=1
                bucket[j]-=1
        return arr
    
solution = Solution()
nums = [20, 54, 26, 31, 17, 44, 77, 93, 55]
maxValue = 100
res = solution.countingSort(nums,maxValue)
print(res)

"""
[17, 20, 26, 31, 44, 54, 55, 77, 93]
"""

8.4、算法分析
当输入的元素是n 个0到k之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。
最佳情况：T(n) = O(n+k)
最差情况：T(n) = O(n+k)
平均情况：T(n) = O(n+k)

9、桶排序

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。

桶排序的工作原理：假设输入数据服从均匀分布，将数据分有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）

9.1、算法描述

人为设置一个BucketSize，作为每个桶所能放置多少个不同数值（例如当BucketSize==5时，该桶可以存放{1，2，3，4，5}这几种数字，但是容量不限，及可以存放100个3）
遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；
从不是空的桶里把排好序的数据拼接起来

注意：如果递归使用桶排序为各个桶排序，则当桶的数量为1时要手动减小BucketSize增加下一循环桶的数量，否则会陷入死循环，导致内存溢出。

9.2、图片展示
9.3、代码实现
9.4、算法分析

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

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

10、基数排序

基数排序也是非比较排序算法，对每一位进行排序，从最低位开始排序，复杂度为O(kn)，为数组长度，k为数组中得数得最大位数；

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

10.1、算法描述

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

10.2、动图展示
在这里插入图片描述
10.3、代码实现

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 25 15:44:27 2021

@author: daicong
"""

class Solution:
    def radix_sort(self,arr):
        digit = 0
        max_digit = 1
        max_value = max(arr)
        #找出列表中最大的位数
        while 10**max_digit < max_value:
            max_digit = max_digit + 1    
        while digit < max_digit:
            temp = [[] for i in range(10)]
            for i in arr:
                #求出每一个元素的个、十、百位的值
                t = int((i/10**digit)%10)
                temp[t].append(i)
            coll = []
            for bucket in temp:
                for i in bucket:
                    coll.append(i)            
            arr = coll
            digit = digit + 1
        return arr

solution = Solution()
nums = [20, 54, 26, 31, 17, 44, 77, 93, 55]
res = solution.radix_sort(nums)
print(res)

"""
[17, 20, 26, 31, 44, 54, 55, 77, 93]
"""

10.4、算法分析
最佳情况：T(n) = O(n * k)
最差情况：T(n) = O(n * k)
平均情况：T(n) = O(n * k)

基数排序有两种方法：

MSD 从高位开始进行排序
LSD 从低位开始进行排序

基数排序 vs 计数排序 vs 桶排序

这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：

基数排序：根据键值的每位数字来分配桶
计数排序：每个桶只存储单一键值
桶排序：每个桶存储一定范围的数值

望长安于日下

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
python基础--十大排序算法

排序算法一览表1、冒泡排序冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢”浮“到数列的顶端。1.1、算法描述比较相邻的元素。如果第一个比第二个大，就交换他们两个；对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；针对所有的元素重复
复制链接

扫一扫