排序算法Python(冒泡、选择、快速、插入、希尔、归并排序)
排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。
我们通常所说的排序算法往往指的是内部排序算法,即数据记录在内存中进行排序。内部排序的分类:
一种是比较排序,时间复杂度O(nlogn) ~ O(n^2),主要有:冒泡排序,选择排序,快速排序,插入排序,希尔排序,归并排序,堆排序等。
另一种是非比较排序,时间复杂度可以达到O(n),主要有:计数排序,基数排序,桶排序等。
常见排序算法的一些特性:
冒泡排序
通过上面的动图也可以看出来,冒泡通过两重循环遍历每一个数后将最大的’冒’出去
冒泡是相邻元素之间的比较,每次把最大的’冒’出去
时间复杂度:O(n^2)
选择排序
选择排序相比冒泡排序不稳定,时间复杂度也是。
选择排序没趟都会产生最小值,它不是相邻元素的比较而是在该元素设置一个索引i。
然后与数组的其他元素依次比较(除了上一个索引值),直到找到小于该元素(索引j)时交换两元素,
接着继续从i索引(此时已经不是原来的数值)值与索引j+1值比较。重复上述比较过程:
冒泡是相邻元素比较,选择不是相邻元素比较
把最小的选出来
快速排序
(1) 从数列中挑出一个基准值。
(2) 将所有比基准值小的摆放在基准前面,所有比基准值大的摆在基准的后面(相同的数可以到任一边);在这个分区退出之后,该基准就处于最终它应该在的地方。
(3) 递归地把”基准值前面的子数列”和”基准值后面的子数列”进行排序。
快速排序的时间复杂度在最坏情况下是O(N2),平均的时间复杂度是O(N*lgN)。
假设有如下数组,将两个哨兵设在左右端,最左端的值为基准
1.右边向左运动,直到找到一个比基准小的数
2.左边向右运动,直到找到一个比基准大的数
3.交换两个数
4.如果两个哨兵不想遇,则继续上述步骤
5.相遇之后和基准交换
这样‘6’就永远在它最终应该待的地方了,对6的前一半和后一半进行上述完整操作即可(递归)
插入排序
- 初始时,a[0]自成1个有序区,无序区为a[1..n-1]。令i=1
- 将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。
- i++并重复第二步直到i==n-1。排序完成。
直接插入排序的时间复杂度是O(N^2)
希尔排序
是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。分组的插入排序
注:
如果索引i,j大于步长gap时,应该一直往前迭代
如代码中的: j-=gap第一次交换数据后,看它是后面的数否还小于前面的数
如2 3 1 5 9 6这个序列以1位步长的话
一次交换后2 1 3 5 9 6此时j指向第二个数,i指向第三个数
所以交换后应该用j-gap往前查看是否前面的更小
归并排序
是分治法的一种,上图可以清晰的描述排序过程
先拆分(递归),后合并
效率为 O(n log n)
'''
冒泡排序
重复走访过要排序的序列,一次比较两个元素,如果他们的顺序错误就将他们进行交换,一次冒上来的是最小的,其次是第二小。
时间复杂度:O(n^2)
空间复杂度:O(1)
稳定性:稳定
'''
def BubbleSort(data):
for i in range(len(data)):
for j in range(len(data)-i-1):
if data[j]>data[j+1]:
data[j+1] , data[j] = data[j] , data[j+1]
'''
选择排序
选择排序相比冒泡排序不稳定,时间复杂度也是。选择排序没趟都会产生最小值,它不是相邻元素的比较而是在该元素设置一个索引i。
然后与数组的其他元素依次比较(除了上一个索引值),直到找到小于该元素(索引j)时交换两元素,
接着继续从i索引(此时已经不是原来的数值)值与索引j+1值比较。重复上述比较过程……简单的原理图如下:
冒泡是相邻元素比较,选择不是相邻元素比较
'''
def SelectionSort(data):
for i in range(len(data)):
for j in range(i+1,len(data)):
if data[j]<data[i]:
data[i] , data[j] = data[j] , data[i]
'''
快速排序
快速排序流程:
(1) 从数列中挑出一个基准值。
(2) 将所有比基准值小的摆放在基准前面,所有比基准值大的摆在基准的后面(相同的数可以到任一边);在这个分区退出之后,该基准就处于最终它应该在的地方。
(3) 递归地把"基准值前面的子数列"和"基准值后面的子数列"进行排序。
快速排序的时间复杂度在最坏情况下是O(N2),平均的时间复杂度是O(N*lgN)。
'''
def QuickSort(lists, left, right):
# 快速排序
if left >= right:
return lists
key =left
low = left
high = right
while left < right:
while left < right and lists[right] >= lists[key]:#如果右边比基准小,停下
right -= 1
while left < right and lists[left] <= lists[key]:#如果左边比基准大,停下
left += 1
lists[right],lists[left]=lists[left],lists[right]#交换现在的左右值
lists[right] ,lists[key]=lists[key],lists[right] #left和right汇合后和基准交换
print_data(data)#交换过程
QuickSort(lists, low, left - 1)
QuickSort(lists, left + 1, high)
return lists
'''
直接插入排序
1. 初始时,a[0]自成1个有序区,无序区为a[1..n-1]。令i=1
2. 将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。
3. i++并重复第二步直到i==n-1。排序完成。
直接插入排序的时间复杂度是O(N2)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N),需要遍历多少次呢?N-1!因此,直接插入排序的时间复杂度是O(N2)。
'''
def InsertionSort(data):
for i in range(1,len(data)):
key=data[i]
j=i-1
while j>=0:
if data[j]>key:
data[j+1]=data[j]
data[j]=key
j-=1
'''
希尔排序
是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。分组的插入排序
j-=gap第一次交换数据后,看它是后面的数否还小于前面的数
如2 3 1 5 9 6这个序列以1位步长的话
一次交换后2 1 3 5 9 6此时j指向第二个数,i指向第三个数
所以交换后应该用j-gap往前查看是否前面的更小
'''
def ShellSort(data):
gap=int(len(data)/2) #排序的分组
while gap>0:
for i in range(gap,len(data)):
j=i-gap
while data[j]>data[i] and j >=0:
data[j],data[i]=data[i],data[j]
j-=gap
i-=gap
gap=int(gap/2)
'''
归并排序
先拆分,后合并
'''
def MergeSort(ls):
if len(ls)<2:
return ls
mid = len(ls) >> 1 #相当于除2取整
left = MergeSort(ls[:mid])
right = MergeSort(ls[mid:])
return merge(left,right)
def merge(left, right):
result = []
i, j = 0, 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
'''打印函数'''
def print_data(data):
for i in data:
print(i,end=' ')
print()
'''测试代码'''
data=[5,9,7,2,3,1,6]
BubbleSort(data)
print_data(data)
data=[5,9,7,2,3,1,6]
SelectionSort(data)
print_data(data)
data=[5,9,7,2,3,1,6]
QuickSort(data,0,6)
print_data(data)
data=[5,9,7,2,3,1,6]
InsertionSort(data)
print_data(data)
data=[5,9,7,2,3,1,6]
ShellSort(data)
print_data(data)
data=[5,9,7,2,3,1,6]
data=MergeSort(data)
print_data(data)
- 59
- 160
- 161
图片来自维基百科
排序算法Python(冒泡、选择、快速、插入、希尔、归并排序)的更多相关文章
- js排序算法总结—冒泡,快速,选择,插入,希尔,归并
相信排序是任何一个程序猿都会用到的东西,今天简单总结记录下常见的排序算法. 一.冒泡排序 说起冒泡排序,可能每个人都不会陌生,实现思路相当简单明了,就是不停的对数组进行两两比较,将较大(较小)的一项放 ...
- js排序算法总结——冒泡,快速,选择,插入,希尔,归并
相信排序是任何一个程序猿都会用到的东西,今天简单总结记录下常见的排序算法. 一.冒泡排序 说起冒泡排序,可能每个人都不会陌生,实现思路相当简单明了,就是不停的对数组进行两两比较,将较大(较小)的一项放 ...
- 44.python排序算法(冒泡+选择)
一,冒泡排序: 是一种简单的排序算法.它重复地遍历要排序的数列,一次比较两个,如果他们的排序错误就把他们交换过来. 冒泡排序是稳定的(所谓稳定性就是两个相同的元素不会交换位置) 冒泡排序算法的运作如下 ...
- javascript数据结构与算法--基本排序算法(冒泡、选择、排序)及效率比较
javascript数据结构与算法--基本排序算法(冒泡.选择.排序)及效率比较 一.数组测试平台. javascript数据结构与算法--基本排序(封装基本数组的操作),封装常规数组操作的函数,比如 ...
- Shell数组以及排序算法(冒泡、直接选择、反转)
Shell数组以及排序算法(冒泡.直接选择.反转) 目录 Shell数组以及排序算法(冒泡.直接选择.反转) 一.数组概述 1. 数组的定义 2. 下标的定义 3. 数组的特点 4. 数组定义的方法 ...
- 排序算法 python实现
一.排序的基本概念和分类 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法. 排序的稳定性: 经过某种排序后,如果两 ...
- 常见排序算法-Python实现
常见排序算法-Python实现 python 排序 算法 1.二分法 python 32行 right = length- : ] ): test_list = [,,,,,, ...
- Java常见排序算法之直接选择排序
在学习算法的过程中,我们难免会接触很多和排序相关的算法.总而言之,对于任何编程人员来说,基本的排序算法是必须要掌握的. 从今天开始,我们将要进行基本的排序算法的讲解.Are you ready?Let ...
- Java排序算法之直接选择排序
Java排序算法之直接选择排序 基本过程:假设一序列为R[0]~R[n-1],第一次用R[0]和R[1]~R[n-1]相比较,若小于R[0],则交换至R[0]位置上.第二次从R[1]~R[n-1]中选 ...
随机推荐
- 南海区行政审批管理系统接口规范v0.3(规划) 3.业务办理API 3.1.businessAuditById【业务办理】
{"c_accept":"Q2015112400002","c_operators":"gz99","v_op ...
- codeforces 708ALetter Cyclic Shift
2019-05-18 09:51:19 加油,加油,fightting !!! https://www.cnblogs.com/ECJTUACM-873284962/p/6375011.html 全为 ...
- Blender插件之Panel
目标 [x] 总结Blender之Panel 总结 Blender之Panel需要从Blender界面组成开始理解. 直观上Blender的界面层次为 Editors ‣ Regions ‣ (Tab ...
- 关于一些UI的插件(杂)
1.时间插件 //日期框 $('.date-picker').datepicker(); 2.checkbox 保存checkbox的值 // 组装选择的标签 var check = $(" ...
- Pinpoint 监控
####Hbase数据################ 参考: 然而没有卵用: https://blog.csdn.net/iamlihongwei/article/details/52882749? ...
- LyX初步
最近写毕业论文少量入手了LyX. 这个工具是两三年前在CTeX群里听说的.当时感觉太高大上,连Linux下用LaTeX都还没搞定,于是没想这个. 但是最近用了LaTeX模板感觉太麻烦,于是试着装了一下 ...
- Android 解决toolbar标题不显示问题
问题原因:toolbar的兼容性有问题 解决办法: setSupportActionBar(toolbar); toolbar使用步骤: 1.编写menu.xml 为了保持兼容需要这样写: andro ...
- hdu2647 Reward 拓扑排序
此题的关键在于分层次,最低一层的人的奖金是888,第二层是888+1 …… 分层可以这样实现.建立反向图.在拓扑排序的时候,第一批入度为0的点就处于第一层,第二批处于第二层 …… 由于是逐个遍历入度为 ...
- OpenCV中GPU模块使用
CUDA IT168的文章系列: Cuda的初始化:http://tech.it168.com/a2011/0715/1218/000001218458.shtml OpenCV: OpenCV中GP ...
- Linux系统编程博客参考
通过看前人的博客更易于把握知识要点 http://www.cnblogs.com/mickole/category/496206.html <Linux系统编程> http://www.c ...