开发者社区> 行者武松> 正文

八大排序算法的Python实现

简介:
+关注继续查看

本文主要介绍了常见的8大排序算法基本概念以及其Python实现方式,如果你是Java程序员,也可以看看之前我们介绍的Java程序员必须掌握的8大排序算法

1、插入排序

描述

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据,算法适用于少量数据的排序,时间复杂度为 O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分:第一部分包含了这个数组的所有元素,但将最后一个元素除外(让数组多一个空间才有插 入的位置),而第二部分就只包含这一个元素(即待插入元素)。在第一部分排序完成后,再将这个最后元素插入到已排好序的第一部分中。

代码实现


  1. def insert_sort(lists): 
  2.     # 插入排序 
  3.     count = len(lists) 
  4.     for i in range(1, count): 
  5.         key = lists[i] 
  6.         j = i - 1 
  7.         while j >= 0
  8.             if lists[j] > key: 
  9.                 lists[j + 1] = lists[j] 
  10.                 lists[j] = key 
  11.             j -= 1 
  12.     return lists 

2、希尔排序

描述

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL.Shell于 1959年提出而得名。 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分 成一组,算法便终止。

代码实现


  1. def shell_sort(lists): 
  2.     # 希尔排序 
  3.     count = len(lists) 
  4.     step = 2 
  5.     group = count / step 
  6.     while group > 0
  7.         for i in range(0, group): 
  8.             j = i + group 
  9.             while j < count: 
  10.                 k = j - group 
  11.                 key = lists[j] 
  12.                 while k >= 0
  13.                     if lists[k] > key: 
  14.                         lists[k + group] = lists[k] 
  15.                         lists[k] = key 
  16.                     k -= group 
  17.                 j += group 
  18.         group /= step 
  19.     return lists 

3、冒泡排序

描述

它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

代码实现


  1. def bubble_sort(lists): 
  2.     # 冒泡排序 
  3.     count = len(lists) 
  4.     for i in range(0, count): 
  5.         for j in range(i + 1, count): 
  6.             if lists[i] > lists[j]: 
  7.                 lists[i], lists[j] = lists[j], lists[i] 
  8.     return lists 

4、快速排序

描述

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

代码实现


  1. def quick_sort(lists, left, right): 
  2.     # 快速排序 
  3.     if left >= right: 
  4.         return lists 
  5.     key = lists[left] 
  6.     low = left 
  7.     high = right 
  8.     while left < right: 
  9.         while left < right and lists[right] >= key: 
  10.             right -= 1 
  11.         lists[left] = lists[right] 
  12.         while left < right and lists[left] <= key: 
  13.             left += 1 
  14.         lists[right] = lists[left] 
  15.     lists[right] = key 
  16.     quick_sort(lists, low, left - 1
  17.     quick_sort(lists, left + 1, high) 
  18.     return lists 

5、直接选择排序

描述

基本思想:第1趟,在待排序记录r1 ~ r[n]中选出最小的记录,将它与r1交换;第2趟,在待排序记录r2 ~ r[n]中选出最小的记录,将它与r2交换;以此类推,第i趟在待排序记录r[i] ~ r[n]中选出最小的记录,将它与r[i]交换,使有序序列不断增长直到全部排序完毕。

代码实现


  1. def select_sort(lists): 
  2.     # 选择排序 
  3.     count = len(lists) 
  4.     for i in range(0, count): 
  5.         min = i 
  6.         for j in range(i + 1, count): 
  7.             if lists[min] > lists[j]: 
  8.                 min = j 
  9.         lists[min], lists[i] = lists[i], lists[min] 
  10.     return lists 

6、堆排序

描述

堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。可以利用数组的特点快速定位指定索引的元 素。堆分为大根堆和小根堆,是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值,即A[PARENT[i]] >= A[i]。在数组的非降序排序中,需要使用的就是大根堆,因为根据大根堆的要求可知,最大的值一定在堆顶。

代码实现


  1. # 调整堆 
  2. def adjust_heap(lists, i, size): 
  3.     lchild = 2 * i + 1 
  4.     rchild = 2 * i + 2 
  5.     max = i 
  6.     if i < size / 2
  7.         if lchild < size and lists[lchild] > lists[max]: 
  8.             max = lchild 
  9.         if rchild < size and lists[rchild] > lists[max]: 
  10.             max = rchild 
  11.         if max != i: 
  12.             lists[max], lists[i] = lists[i], lists[max] 
  13.             adjust_heap(lists, max, size) 
  14.  
  15. # 创建堆 
  16. def build_heap(lists, size): 
  17.     for i in range(0, (size/2))[::-1]: 
  18.         adjust_heap(lists, i, size) 
  19.  
  20. # 堆排序 
  21. def heap_sort(lists): 
  22.     size = len(lists) 
  23.     build_heap(lists, size) 
  24.     for i in range(0, size)[::-1]: 
  25.         lists[0], lists[i] = lists[i], lists[0
  26.         adjust_heap(lists, 0, i) 

7、归并排序

描述

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

归并过程为:比较a[i]和a[j]的大小,若a[i]≤a[j],则将第一个有序表中的元素a[i]复制到r[k]中,并令i和k分别加上1;否 则将第二个有序表中的元素a[j]复制到r[k]中,并令j和k分别加上1,如此循环下去,直到其中一个有序表取完,然后再将另一个有序表中剩余的元素复 制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现,先把待排序区间[s,t]以中点二分,接着把左边子区间排序,再把右边子区间排序, 最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

代码实现


  1. def merge(left, right): 
  2.     i, j = 00 
  3.     result = [] 
  4.     while i < len(left) and j < len(right): 
  5.         if left[i] <= right[j]: 
  6.             result.append(left[i]) 
  7.             i += 1 
  8.         else
  9.             result.append(right[j]) 
  10.             j += 1 
  11.     result += left[i:] 
  12.     result += right[j:] 
  13.     return result 
  14.  
  15. def merge_sort(lists): 
  16.     # 归并排序 
  17.     if len(lists) <= 1
  18.         return lists 
  19.     num = len(lists) / 2 
  20.     left = merge_sort(lists[:num]) 
  21.     right = merge_sort(lists[num:]) 
  22.     return merge(left, right) 

8、基数排序

描述

基数排序(radix sort)属于“分配式排序”(distribution sort),又称“桶子法”(bucket sort)或bin sort,顾名思义,它是透过键值的部份资讯,将要排序的元素分配至某些“桶”中,藉以达到排序的作用,基数排序法是属于稳定性的排序,其时间复杂度为O (nlog(r)m),其中r为所采取的基数,而m为堆数,在某些时候,基数排序法的效率高于其它的稳定性排序法。

代码实现


  1. import math 
  2. def radix_sort(lists, radix=10): 
  3.     k = int(math.ceil(math.log(max(lists), radix))) 
  4.     bucket = [[] for i in range(radix)] 
  5.     for i in range(1, k+1): 
  6.         for j in lists: 
  7.             bucket[j/(radix**(i-1)) % (radix**i)].append(j) 
  8.         del lists[:] 
  9.         for z in bucket: 
  10.             lists += z 
  11.             del z[:] 
  12.     return lists 



来源:51CTO

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Python实现一个简单的区块链
本文介绍如何用Python实现一个简单的区块链。
217 0
python 实现pacs功能 推送下拉影像
python 实现dcmtk关联pacs功能 推送下拉影像
123 0
Leedcode 每日一练 搜索二维矩阵Ⅰ Python实现
Leedcode 每日一练 搜索二维矩阵Ⅰ Python实现
54 0
Leecode加法题目3个 每日练习 Python实现
Leecode加法题目3个 每日练习 Python实现
36 0
Python实现微信消息连续发送
Python实现微信消息连续发送
190 0
Python print() 打印两个 list ,实现中间换行
Python print() 打印两个 list ,实现中间换行
332 0
python实现微信小游戏“飞机大战”
python实现微信小游戏“飞机大战”
112 0
Python分分钟实现图书管理系统(含代码)
Python分分钟实现图书管理系统(含代码)
129 0
Python:使用PyJWT实现JSON Web Tokens加密解密
Python:使用PyJWT实现JSON Web Tokens加密解密
135 0
Python实现因子分析(附案例实战)
Python实现因子分析(附案例实战)
297 0
Python实现聚类分析和数据降维
Python实现聚类分析和数据降维
451 0
Python实现线性回归和梯度下降算法
Python实现线性回归和梯度下降算法
88 0
Python实现KNN算法和交叉验证
Python实现KNN算法和交叉验证
154 0
Python实现卡方检验和相关性分析
Python实现卡方检验和相关性分析
437 0
利用python实现Apriori关联规则算法
利用python实现Apriori关联规则算法
162 0
+关注
行者武松
杀人者,打虎武松也。
文章
问答
视频
相关电子书
更多
双剑合璧-Python和大数据计算平台的结合
立即下载
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
相关实验场景
更多