[算法]用Python实现十大排序算法

1. 冒泡排序

给定一串数组，里面的较大值一个接一个地流向尾部

def bubbleSort(arr):for i in range(len(arr)):j = 0while j < len(arr) - i - 1:if arr[j] > arr[j + 1]:arr[j], arr[j + 1] = arr[j + 1], arr[j]j += 1

优化版本，即能够探测到前置部分已有序，终点前移

def bubbleSort(arr):n=len(arr)-1while n>0:j,end= 0,0while j < n:if arr[j] > arr[j + 1]:arr[j], arr[j + 1] = arr[j + 1], arr[j]end= jj += 1n=end

2. 选择排序

每次从待排序数组中拿出最大的放到后面去

def selectSort(arr):for i in range(len(arr), 0, -1):maxIdx = 0for j in range(i):if arr[maxIdx] < arr[j]:maxIdx = jarr[maxIdx], arr[i - 1] = arr[i - 1], arr[maxIdx]

3. 插入排序

从头遍历数组，每次把当前位置的值插入到前面有序队列中

def insertSort(arr):for i in range(1, len(arr)):val, j = arr[i], i - 1while j >= 0 and val < arr[j]:arr[j + 1] = arr[j]j -= 1arr[j + 1] = val

4. 希尔排序

利用间隔将数组拆分，比如数组[0,1,2,3,4,5,6,7]，按照间隔4拆分为4个子集[0,4]、[1,5]、[2,6]、[3,7]分别进行插入排序，之后再利用间隔2拆分成2个子集分别进行插入排序，再利用间隔1即本身插入排序。

def shellSort(arr):s = len(arr) // 2while s > 0:for i in range(0, s):for j in range(i + s, len(arr), s):val, k = arr[j], j - swhile k >= 0 and val < arr[k]:arr[k + s] = arr[k]k -= sarr[k + s] = vals //= 2

为了体现出和插入排序的关联，对3.插入排序加入了起点和间隔控制，嵌入到希尔排序中如下

def insertSort(arr, start, interval):for i in range(start, len(arr)):val, j = arr[i], i - intervalwhile j >= 0 and val < arr[j]:arr[j + interval] = arr[j]j -= intervalarr[j + interval] = valdef shellSort(arr):s = len(arr) // 2while s > 0:for i in range(0, s):insertSort(arr, i + s, s)s //= 2

5. 归并排序

有序数组 = 有序子数组1 + 有序子数组2

def mergeSort(arr):subMergeSort(arr, 0, len(arr))def subMergeSort(arr, left, right):if left >= right - 1:returnmid = left + (right - left) // 2subMergeSort(arr, left, mid)subMergeSort(arr, mid, right)tmp = arr[left:mid]idx = 0while idx < len(tmp):if mid == right or tmp[idx] <= arr[mid]:arr[left] = tmp[idx]idx += 1else:arr[left] = arr[mid]mid += 1left += 1

6. 快速排序

将元素放到本应该有序的正确位置，即左边的都小于等于自己，右边的都大于自己

def quickSort(arr):subQuickSort(arr, 0, len(arr))def subQuickSort(arr, left, right):if left >= right:returnval = arr[left]low, idx = left + 1, left + 1while idx < right:if val >= arr[idx]:arr[low], arr[idx] = arr[idx], arr[low]low += 1idx += 1arr[low - 1], arr[left] = arr[left], arr[low - 1]subQuickSort(arr, left, low - 1)subQuickSort(arr, low, right)

7. 堆排序

首先构造堆，之后不断从堆顶取出即可

import copyclass Myheap:def __init__(self, arr):self.arr = copy.deepcopy(arr)self.len = len(arr)self.heapSort()def heapSort(self):idx = 0for i in range(self.len // 2, -1, -1):self.downAdjust(i)idx += 1def downAdjust(self, pos):left = pos * 2 + 1val = self.arr[pos]while left < self.len:if left + 1 < self.len and self.arr[left] > self.arr[left + 1]:left = left + 1if val <= self.arr[left]:self.arr[pos] = valreturnself.arr[pos] = self.arr[left]pos = leftleft = pos * 2 + 1self.arr[pos] = valdef headPop(self):val, self.arr[0] = self.arr[0], self.arr[-1]self.arr = self.arr[:-1]self.len -= 1if self.len > 0:self.downAdjust(0)return valdef heapSort(arr):h = Myheap(arr)res = []while h.len > 0:res.append(h.headPop())return res

8. 计数排序

统计元素出现的次数

def countSort(arr):res = list()if len(arr) == 0:return resmaxV, minV = max(arr), min(arr)tmp = [0] * (maxV - minV + 1)print(tmp)for v in arr:tmp[v - minV] += 1for idx, v in enumerate(tmp):res += [idx + minV] * vreturn res

9. 桶排序

将元素分布到不同的桶里面(可以利用hash,这里为了方便有点类似计数排序)，之后每个桶分别排序，最后可以归并(这里因为分配算法最后结果有序，就没有归并)

#k表示每个桶的最大容量
def bucketSort(arr, k):res = list()if len(arr) == 0:return resmaxV, minV = max(arr), min(arr)tmp = [[] for _ in range(((maxV - minV) // k + 1))]for v in arr:tmp[(v - minV) // k].append(v)for idx, v in enumerate(tmp):r = sorted(v)res += rreturn res

10. 基数排序

# k表示十进制的最大位数
def radixSort(arr):maxV = max(arr)k = 1tmp = maxVwhile tmp // 10:tmp //= 10tmp += 1tmp = [[] for _ in range(10)]for i in range(k):for j in arr:idx = j // (pow(10, i)) % 10tmp[idx].append(j)start = 0for v in tmp:arr[start : start + len(v)] = vstart += len(v)tmp = [[] for _ in range(10)]

时间空间复杂度

排序算法	平均时间复杂度	最好情况	最坏情况	空间复杂度	原地排序	稳定性
冒泡排序	O(n²)	O(n)	O(n²)	O(1)	True	稳定
选择排序	O(n²)	O(n²)	O(n²)	O(1)	True	不稳定
插入排序	O(n²)	O(n)	O(n²)	O(1)	True	稳定
希尔排序	O(nlogn)	O(nlog²n)	O(nlog²n)	O(1)	True	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	False	稳定
快速排序	O(nlogn)	O(nlogn)	O(n²)	O(logn)	True	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	True	不稳定
计数排序	O(n+k)	O(n+k)	O(n+k)	O(k)	False	稳定
桶排序	O(n+k)	O(n+k)	O(n²)	O(n+k)	False	稳定
基数排序	O(n*k)	O(n*k)	O(n*k)	O(n+k)	False	稳定

还有另一些特定场景的排序：睡眠排序、面条排序、猴子排序等等。

参考文档：

https://www.cnblogs.com/itsharehome/p/11058010.html

[算法]用Python实现十大排序算法相关推荐

数据结构与算法--5.Python实现十大排序算法
文章目录 0. 相关概念一. 冒泡排序二. 选择排序三. 插入排序四. 希尔排序五. 快速排序六. 归并排序七. 其他 0. 相关概念稳定:如果a原本在b前面,而a=b,排序之后a仍然 ...
一篇夯实一个知识点系列－－python实现十大排序算法
写在前面排序是查找是算法中最重要的两个概念,我们大多数情况下都在进行查找和排序.科学家们穷尽努力,想使得排序和查找能够更加快速.本篇文章用Python实现十大排序算法. 很多人学习python,不知 ...
希尔排序是一种稳定的排序算法_全面解析十大排序算法之四：希尔排序
点击上方蓝字关注我们吧 1. 十种排序算法的复杂度和稳定性时间复杂度:一个算法消耗所需要的时间空间复杂度:运行一个算法所需要的内存时间稳定性:如一个排列数组:1.4.5.6.4.7. 此时有一对 ...
选择排序算法流程图_C#实现——十大排序算法之选择排序
选择排序法 1.工作原理(算法思路) 给定一个待排序数组,找到数组中最小的那个元素如果最小元素不是待排序数组的第一个元素,则将其和第一个元素互换在剩下的元素中,重复1.2过程,直到排序完成. 2. ...
八十八、Python | 十大排序算法系列（下篇）
@Author:Runsen @Date:2020/7/10 人生最重要的不是所站的位置,而是内心所朝的方向.只要我在每篇博文中写得自己体会,修炼身心:在每天的不断重复学习中,耐住寂寞,练就真功,不畏 ...
八十七、Python | 十大排序算法系列（上篇）
@Author:Runsen @Date:2020/7/10 人生最重要的不是所站的位置,而是内心所朝的方向.只要我在每篇博文中写得自己体会,修炼身心:在每天的不断重复学习中,耐住寂寞,练就真功,不畏 ...
这或许是东半球分析十大排序算法最好的一篇文章
作者 | 不该相遇在秋天转载自五分钟学算法(ID:CXYxiaowu) 前言本文全长 14237 字,配有 70 张图片和动画,和你一起一步步看懂排序算法的运行过程. 预计阅读时间 47 分钟,强 ...
「干货总结」程序员必知必会的十大排序算法
点击上方好好学java ,选择星标公众号重磅资讯.干货,第一时间送达今日推荐:硬刚一周,3W字总结,一年的经验告诉你如何准备校招! 个人原创100W+访问量博客:点击前往,查看更多绪论身 ...
「归纳|总结」程序员必知必会的十大排序算法
微信搜一搜「bigsai」关注这个有趣的程序员新人原创公众号,求支持一下!你的点赞三连肯定对我至关重要! 文章已收录在我的Github bigsai-algorithm 欢迎star 本文目录绪 ...
归并排序执行次数_十大排序算法，看这篇就够了
排序算法分类[1][2] 比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此也称为非线性时间比较类排序. 非比较类排序:不通过比较来决定元素间的相对次序,它可以 ...