https://www.cnblogs.com/onepixel/p/7674659.html这个文章很nice

https://www.bilibili.com/video/av685670?from=search&seid=1637373535603658338这个动图优秀

https://www.icourse163.org/course/ZJU-93001   MOOC浙大 数据结构 陈越、何钦铭

VisuAlgo - visualising data structures and algorithms through animation    数据结构与算法的可视化网站  更容易让人感性理解各种算法

冒泡排序、选择排序、插入排序这三个是最慢也是最经典的三个排序算法

快速排序对于大的乱数串列一般相信是最快的已知排序

冒泡排序 bubble sort

最简单的排序算法,也是效率最差的,因为它必须在最终位置知道前交换,浪费许多“交换操作”

如果列表已经排序,则是最好情况,遍历期间无需交换,如果发现已经排序,可以提前终止,这种修改下的冒泡通常称为短冒泡排序

时间复杂度: 平均O(n^2)    最差O(n^2)     最好O(n)

空间复杂度:O(1)

稳定

#测试输入数组
alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #冒泡排序
for i in range(len(alist)-1):
for j in range(len(alist)-1-i):
if alist[j] > alist[j+1]:
alist[j],alist[j+1] = alist[j+1],alist[j] #排序结果输出
print('sorted:',alist)

选择排序 selection sort

选择排序改进了冒泡排序,每次遍历列表只做一次交换

时间复杂度:平均O(n^2)    最差O(n^2)    最好O(n^2)

空间复杂度:O(1)

不稳定

#测试输入数组
alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #选择排序
for i in range(len(alist)-1):
least = i
for j in range(i+1,len(alist)):
if alist[j] < alist[least]:
least = j
if least != i:
alist[least],alist[i] = alist[i],alist[least] #排序结果输出
print('sorted:',alist)

插入排序 insertion sort

它始终在列表的较低位置维护一个排序的子列表,然后将每个新项 “插入” 回先前的子列表,使得排序的子列表成为较大的一个项

时间复杂度: 平均O(n^2)    最差O(n^2)     最好O(n)

空间复杂度:O(1)

稳定

#测试输入数组
alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #插入排序
for i in range(1,len(alist)):
j = i;
while j>0 and alist[j-1]>alist[j]:
alist[j-1],alist[j] = alist[j],alist[j-1]
j -= 1 #排序结果输出
print('sorted:',alist)

希尔排序 shell sort

是1959年Shell发明,第一个突破O(n^2)的排序,是对简单插入排序的改进,与插入排序不同的是它优先比较距离较远的元素,又叫“递减增量排序”

是针对插入排序以下2特点改进:在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率;一般来说是低效的,因为插入排序每次只能将数据移动一位

希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步

gap概念,gap递减,最后一步就是插入排序,但是此时几乎已经排好序了

gap是希尔排序核心

出名的gap设置Marcin Ciura's gap sequence ,gaps = [701, 301, 132, 57, 23, 10, 4, 1],不过下面例子用数组长度不断整除2得到的序列作为gaps

时间复杂度:平均O(n(logn)^2)    最差O(n^2)    最好O(n)

空间复杂度:O(1)

不稳定

#测试输入数组
alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #希尔排序
gap = len(alist)//2
while gap>0:
#对每个gap做插入排序
for i in range(gap,len(alist)):
j = i
while j>=gap and alist[j-gap]>alist[j]:
alist[j-gap],alist[j] = alist[j],alist[j-gap]
j -= gap
gap = gap//2 #排序结果输出
print('sorted:',alist)

归并排序 merge sort

分而治之的策略来提高性能,是分治法的典型应用

归并排序是一种递归算法,不断将列表拆分为一半

二路归并 多路归并

缺点是在合并过程需要额外存储空间

时间复杂度: 平均O(nlogn)    最差O(nlogn)      最好O(nlogn)

空间复杂度:O(n)

稳定

#测试输入数组
alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #归并排序
def merge_sort(ilist):
def merge(left, right):
result = []
while left and right:
result.append((left if left[0] <= right[0] else right).pop(0))
return result + left + right if len(ilist) <= 1:
return ilist
mid = len(ilist) // 2
return merge(merge_sort(ilist[:mid]), merge_sort(ilist[mid:])) #排序结果输出
print('sorted:',merge_sort(alist))

快速排序 quick sort

与归并排序相同,采用分治法,而不使用额外存储

是对冒泡排序的改进

通常明显比其他算法更快,因为它的内部循环可以在大部分的架构上很有效的达成

简单的版本和归并排序一样不好,需要额外存储空间,但是可以改为in-place版本,也就不要额外空间了

时间复杂度: 平均O(nlogn)    最差O(n^2)      最好O(nlogn)

空间复杂度:O(nlogn)

不稳定

#测试输入数组
alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #快速排序
def quick_sort(ilist):
length = len(ilist)
if length <= 1:
return ilist
else:
# Use the last element as the first pivot
pivot = ilist.pop()
# Put elements greater than pivot in greater list
# Put elements lesser than pivot in lesser list
greater, lesser = [], []
for element in ilist:
if element > pivot:
greater.append(element)
else:
lesser.append(element)
return quick_sort(lesser) + [pivot] + quick_sort(greater) #排序结果输出
print('sorted:',quick_sort(alist))

堆排序 heap sort

是对选择排序的一种改进

利用堆这种数据结构所设计的算法 近似完全二叉树

堆通常通过一维数组实  大根堆  小根堆

时间复杂度:平均O(nlogn)    最差O(nlogn)      最好O(nlogn)

空间复杂度:O(1)

不稳定

#测试输入数组
alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #堆排序
def heapify(unsorted, index, heap_size):
largest = index
left_index = 2 * index + 1
right_index = 2 * index + 2
if left_index < heap_size and unsorted[left_index] > unsorted[largest]:
largest = left_index if right_index < heap_size and unsorted[right_index] > unsorted[largest]:
largest = right_index if largest != index:
unsorted[largest], unsorted[index] = unsorted[index], unsorted[largest]
heapify(unsorted, largest, heap_size) def heap_sort(unsorted):
n = len(unsorted)
for i in range(n // 2 - 1, -1, -1):
heapify(unsorted, i, n)
for i in range(n - 1, 0, -1):
unsorted[0], unsorted[i] = unsorted[i], unsorted[0]
heapify(unsorted, 0, i)
return unsorted #排序结果输出
print('sorted:',heap_sort(alist))

Python经典排序算法的更多相关文章

  1. python 经典排序算法

    python 经典排序算法 排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存.常见的内部排序算 ...

  2. 经典排序算法总结与实现 ---python

    原文:http://wuchong.me/blog/2014/02/09/algorithm-sort-summary/ 经典排序算法在面试中占有很大的比重,也是基础,为了未雨绸缪,在寒假里整理并用P ...

  3. 经典排序算法及python实现

    今天我们来谈谈几种经典排序算法,然后用python来实现,最后通过数据来比较几个算法时间 选择排序 选择排序(Selection sort)是一种简单直观的排序算法.它的工作原理是每一次从待排序的数据 ...

  4. 十大经典排序算法(python实现)(原创)

    个人最喜欢的排序方法是非比较类的计数排序,简单粗暴.专治花里胡哨!!! 使用场景: 1,空间复杂度 越低越好.n值较大: 堆排序 O(nlog2n) O(1) 2,无空间复杂度要求.n值较大: 桶排序 ...

  5. 经典排序算法的总结及其Python实现

    经典排序算法总结: 结论: 排序算法无绝对优劣之分. 不稳定的排序算法有:选择排序.希尔排序.快速排序.堆排序(口诀:“快速.选择.希尔.堆”).其他排序算法均为稳定的排序算法. 第一趟排序后就能确定 ...

  6. 经典排序算法及总结(python实现)

    目录 1.排序的基本概念和分类 排序的稳定性: 内排序和外排序 影响内排序算法性能的三个因素: 根据排序过程中借助的主要操作,可把内排序分为: 按照算法复杂度可分为两类: 2.冒泡排序 BubbleS ...

  7. python实现十大经典排序算法

    Python实现十大经典排序算法 代码最后面会给出完整版,或者可以从我的Githubfork,想看动图的同学可以去这里看看: 小结: 运行方式,将最后面的代码copy出去,直接python sort. ...

  8. 用Python实现十大经典排序算法-插入、选择、快速、冒泡、归并等

    本文来用图文的方式详细讲解了Python十大经典排序算法 —— 插入排序.选择排序.快速排序.冒泡排序.归并排序.希尔排序.插入排序.桶排序.基数排序.计数排序算法,想要学习的你们,继续阅读下去吧,如 ...

  9. 十大经典排序算法最强总结(含Java、Python码实现)

    引言 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法.排序算法在很多领域得到相当地重视,尤其是在大量数据的处理方面 ...

随机推荐

  1. Gym安装ubuntu16.04

    Step1:将gym克隆到计算机上: git clone https://github.com/openai/gym.git 如果你的电脑没有安装git,那么键入 sudo apt install g ...

  2. HTML入门归纳--JavaScript

    本人一直在从事.net的开发,界面都是采用的WPF,近期花了一个多月进行HTML前端的学习,在这里呢进行学习总结和归纳. 本系列将主要分为4个模块: 控件 样式 布局 JavaScript 根据多年W ...

  3. 10day 系统安全优化

    系统安全相关优化(将一些安全服务进行关闭) 1. 防火墙服务程序 centos6 查看防护墙服务状态 /etc/init.d/iptables status 临时关闭防火墙服务 /etc/init.d ...

  4. Mac 配置cron

    请参考:https://www.cnblogs.com/EasonJim/p/7819635.html 查看 crontab 是否启动 sudo launchctl list | grep cron ...

  5. mtrace 简介

    内存泄露问题一般会再长时间运行的程序中暴露出来.而且一般很难定位和查找. linux 提供mtrace/muntrace来检测程序是否有内存泄露.一般来说要检测哪一段代码是否有内存泄露,就可以用这一对 ...

  6. 归并非递归、快排递归及非递归的C++实现及时间效率对比。。

    今天看剑指offer突然发现下学期都要去面试了,还没自己实现过快排非递归和归并非递归,这怎么能行呢,于是就写了一下. (虽然有点卡壳,又回去翻了下算导,还是顺利写出来了) 先放图: 一亿数据量: #p ...

  7. Java 线程高级

    1.volatile关键字:当多个线程操作共享数据时,可以保证内存中的数据可见,相较于syncronized是一种较为轻量级的同步策略, 注意:1.volatile不具有“互斥性” 2.volatil ...

  8. centos7.5下安装jenkins

    最近从头搭建了一套python+selenium+pytest+allure+Jenkins的环境,虽然网上挺多的,不过还是记录下来,毕竟坑还是挺多的....... 先从搭建jenkins开始把! 方 ...

  9. 实现一个简易的Unity网络同步引擎——netgo

    实现一个简易的Unity网络同步引擎Netgo 目前GOLANG有大行其道的趋势,尤其是在网络编程方面.因为和c/c++比较起来,虽然GC占用了一部分机器性能,但是出错概率小了,开发效率大大提升,而且 ...

  10. 序列变换 HDU - 5256

    序列变换 HDU - 5256 题目链接 题目 我们有一个数列A1,A2...An,你现在要求修改数量最少的元素,使得这个数列严格递增.其中无论是修改前还是修改后,每个元素都必须是整数. 请输出最少需 ...