Python数据结构与算法(几种排序)小结


Posted in Python onJune 22, 2019

Python数据结构与算法(几种排序)

数据结构与算法(Python)

冒泡排序

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

冒泡排序算法的运作如下:

  1. 比较相邻的元素。如果第一个比第二个大(升序),就交换他们两个。
  2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
  3. 针对所有的元素重复以上的步骤,除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

冒泡排序的分析

交换过程图示(第一次):

 Python数据结构与算法(几种排序)小结

那么我们需要进行n-1次冒泡过程,每次对应的比较次数如下图所示:

def bubble_sort(alist):
 for j in range(len(alist)-1,0,-1):
 # j表示每次遍历需要比较的次数,是逐渐减小的
 for i in range(j):
  if alist[i] > alist[i+1]:
  alist[i], alist[i+1] = alist[i+1], alist[i]
li = [54,26,93,17,77,31,44,55,20]
bubble_sort(li)
print(li)

时间复杂度

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

冒泡排序的演示

效果:

Python数据结构与算法(几种排序)小结

选择排序

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

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上,则它不会被移动。选择排序每次交换一对元素,它们当中至少有一个将被移到其最终位置上,因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中,选择排序属于非常好的一种。

选择排序分析

排序过程:

Python数据结构与算法(几种排序)小结

 Python数据结构与算法(几种排序)小结

红色表示当前最小值,黄色表示已排序序列,蓝色表示当前位置。

def selection_sort(alist):
 n = len(alist)
 # 需要进行n-1次选择操作
 for i in range(n-1):
 # 记录最小位置
 min_index = i
 # 从i+1位置到末尾选择出最小数据
 for j in range(i+1, n):
  if alist[j] < alist[min_index]:
  min_index = j
 # 如果选择出的数据不在正确位置,进行交换
 if min_index != i:
  alist[i], alist[min_index] = alist[min_index], alist[i]
alist = [54,226,93,17,77,31,44,55,20]
selection_sort(alist)
print(alist)

时间复杂度

  1. 最优时间复杂度:O(n2)
  2. 最坏时间复杂度:O(n2)
  3. 稳定性:不稳定(考虑升序每次选择最大的情况)

选择排序演示 

Python数据结构与算法(几种排序)小结

插入排序

插入排序(英语:Insertion Sort)是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

插入排序分析

Python数据结构与算法(几种排序)小结

Python数据结构与算法(几种排序)小结

def insert_sort(alist):
 # 从第二个位置,即下标为1的元素开始向前插入
 for i in range(1, len(alist)):
 # 从第i个元素开始向前比较,如果小于前一个元素,交换位置
 for j in range(i, 0, -1):
  if alist[j] < alist[j-1]:
  alist[j], alist[j-1] = alist[j-1], alist[j]
alist = [54,26,93,17,77,31,44,55,20]
insert_sort(alist)
print(alist)

时间复杂度

  1. 最优时间复杂度:O(n) (升序排列,序列已经处于升序状态)
  2. 最坏时间复杂度:O(n2)
  3. 稳定性:稳定

插入排序演示

Python数据结构与算法(几种排序)小结

快速排序

快速排序(英语:Quicksort),又称划分交换排序(partition-exchange sort),通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

步骤为:

从数列中挑出一个元素,称为"基准"(pivot),
重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递归下去,但是这个算法总会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。

快速排序的分析

Python数据结构与算法(几种排序)小结

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向左移动
  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)

时间复杂度

  1. 最优时间复杂度:O(nlogn)
  2. 最坏时间复杂度:O(n2)
  3. 稳定性:不稳定

从一开始快速排序平均需要花费O(n log n)时间的描述并不明显。但是不难观察到的是分区运算,数组的元素都会在每次循环中走访过一次,使用O(n)的时间。在使用结合(concatenation)的版本中,这项运算也是O(n)。

在最好的情况,每次我们运行一次分区,我们会把一个数列分为两个几近相等的片段。这个意思就是每次递归调用处理一半大小的数列。因此,在到达大小为一的数列前,我们只要作log n次嵌套的调用。这个意思就是调用树的深度是O(log n)。但是在同一层次结构的两个程序调用中,不会处理到原来数列的相同部分;因此,程序调用的每一层次结构总共全部仅需要O(n)的时间(每个调用有某些共同的额外耗费,但是因为在每一层次结构仅仅只有O(n)个调用,这些被归纳在O(n)系数中)。结果是这个算法仅需使用O(n log n)时间。

快速排序演示

Python数据结构与算法(几种排序)小结

希尔排序

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

希尔排序过程

希尔排序的基本思想是:将数组列在一个表中并对列分别进行插入排序,重复这过程,不过每次用更长的列(步长更长了,列数更少了)来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法,算法本身还是使用数组进行排序。

例如,假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ],如果我们以步长为5开始进行排序,我们可以通过将这列表放在有5列的表中来更好地描述算法,这样他们就应该看起来是这样(竖着的元素是步长组成):

13 14 94 33 82

25 59 94 65 23

45 27 73 25 39

10

然后我们对每列进行排序:

10 14 73 25 23

13 27 94 33 39

25 59 94 65 82

45

将上述四行数字,依序接在一起时我们得到:[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。这时10已经移至正确位置了,然后再以3为步长进行排序:

10 14 73

25 23 13

27 94 33

39 25 59

94 65 82

45

排序之后变为:

10 14 13

25 23 33

27 25 59

39 65 73

45 94 82

94

最后以1步长进行排序(此时就是简单的插入排序了)

希尔排序的分析 

Python数据结构与算法(几种排序)小结

def shell_sort(alist):
 n = len(alist)
 # 初始步长
 gap = n / 2
 while gap > 0:
  # 按步长进行插入排序
  for i in range(gap, n):
   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
alist = [54,26,93,17,77,31,44,55,20]
shell_sort(alist)
print(alist)

 时间复杂度

  1. 最优时间复杂度:根据步长序列的不同而不同
  2. 最坏时间复杂度:O(n2)
  3. 稳定想:不稳定

希尔排序演示

Python数据结构与算法(几种排序)小结

归并排序

归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组,再合并数组。

将数组分解最小之后,然后合并两个有序数组,基本思路是比较两个数组的最前面的数,谁小就先取谁,取了后相应的指针就往后移一位。然后再比较,直至一个数组为空,最后把另一个数组的剩余部分复制过来即可。

归并排序的分析

Python数据结构与算法(几种排序)小结

def merge_sort(alist):
 if len(alist) <= 1:
  return alist
 # 二分分解
 num = len(alist)/2
 left = merge_sort(alist[:num])
 right = merge_sort(alist[num:])
 # 合并
 return merge(left,right)
def merge(left, right):
 '''合并操作,将两个有序数组left[]和right[]合并成一个大的有序数组'''
 #left与right的下标指针
 l, r = 0, 0
 result = []
 while l<len(left) and r<len(right):
  if left[l] < right[r]:
   result.append(left[l])
   l += 1
  else:
   result.append(right[r])
   r += 1
 result += left[l:]
 result += right[r:]
 return result
alist = [54,26,93,17,77,31,44,55,20]
sorted_alist = mergeSort(alist)
print(sorted_alist)

 时间复杂度

  1. 最优时间复杂度:O(nlogn)
  2. 最坏时间复杂度:O(nlogn)
  3. 稳定性:稳定 

常见排序算法效率比较

Python数据结构与算法(几种排序)小结

搜索

搜索是在一个项目集合中找到一个特定项目的算法过程。搜索通常的答案是真的或假的,因为该项目是否存在。 搜索的几种常见方法:顺序查找、二分法查找、二叉树查找、哈希查找

二分法查找

二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。

Python数据结构与算法(几种排序)小结

 二分法查找实现

(非递归实现)

def binary_search(alist, item):
  first = 0
  last = len(alist)-1
  while first<=last:
   midpoint = (first + last)/2
   if alist[midpoint] == item:
    return True
   elif item < alist[midpoint]:
    last = midpoint-1
   else:
    first = midpoint+1
 return False
testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))
(递归实现)
def binary_search(alist, item):
 if len(alist) == 0:
  return False
 else:
  midpoint = len(alist)//2
  if alist[midpoint]==item:
   return True
  else:
   if item<alist[midpoint]:
   return binary_search(alist[:midpoint],item)
   else:
   return binary_search(alist[midpoint+1:],item)
testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))

时间复杂度

  1. 最优时间复杂度:O(1)
  2. 最坏时间复杂度:O(logn)

总结

以上所述是小编给大家介绍的Python数据结构与算法(几种排序)小结,希望对大家有帮助,如果大家有任何疑问欢迎给我留言,小编会及时回复大家的!

Python 相关文章推荐
Python3里的super()和__class__使用介绍
Apr 23 Python
在Python中处理字符串之isdigit()方法的使用
May 18 Python
python监控进程脚本
Apr 12 Python
Python中一些不为人知的基础技巧总结
May 19 Python
python 通过可变参数计算n个数的乘积方法
Jun 13 Python
Django 项目重命名的实现步骤解析
Aug 14 Python
python3.7 openpyxl 删除指定一列或者一行的代码
Oct 08 Python
Python中包的用法及安装
Feb 11 Python
python实现udp聊天窗口
Mar 31 Python
详解scrapy内置中间件的顺序
Sep 28 Python
Django migrate报错的解决方案
May 20 Python
numpy array找出符合条件的数并赋值的示例代码
Jun 01 Python
python+opencv实现摄像头调用的方法
Jun 22 #Python
python算法与数据结构之冒泡排序实例详解
Jun 22 #Python
分析运行中的 Python 进程详细解析
Jun 22 #Python
机器学习实战之knn算法pandas
Jun 22 #Python
解决py2exe打包后,总是多显示一个DOS黑色窗口的问题
Jun 21 #Python
pyinstaller打包单个exe后无法执行错误的解决方法
Jun 21 #Python
pyinstaller打包多个py文件和去除cmd黑框的方法
Jun 21 #Python
You might like
PHP中addslashes()和stripslashes()实现字符串转义和还原用法实例
2016/01/07 PHP
PHP版本的选择5.2.17 5.3.27 5.3.28 5.4 5.5兼容性问题分析
2016/04/04 PHP
PHP设置images目录不充许http访问的方法
2016/11/01 PHP
编写可维护面向对象的JavaScript代码[翻译]
2011/02/12 Javascript
js实现仿MSN带关闭功能的右下角弹窗代码
2015/09/04 Javascript
原生javascript实现addClass,removeClass,hasClass函数
2016/02/25 Javascript
将List对象列表转换成JSON格式的类实现方法
2016/07/04 Javascript
浅谈js中StringBuffer类的实现方法及使用
2016/09/02 Javascript
关于Vue.js一些问题和思考学习笔记(1)
2016/12/02 Javascript
js 实现省市区三级联动菜单效果
2017/02/20 Javascript
AngularJS使用ui-route实现多层嵌套路由的示例
2018/01/10 Javascript
小程序getLocation需要在app.json中声明permission字段
2019/04/04 Javascript
微信小程序通过js实现瀑布流布局详解
2019/08/28 Javascript
浅谈layui框架自带分页和表格重载的接口解析问题
2019/09/11 Javascript
详解Vue 项目中的几个实用组件(ts)
2019/10/29 Javascript
vue实现评价星星功能
2020/06/30 Javascript
[00:12]DAC2018 Miracle-站上中单舞台,他能否再写奇迹?
2018/04/06 DOTA
Python中super关键字用法实例分析
2015/05/28 Python
python3使用urllib模块制作网络爬虫
2016/04/08 Python
Python yield 使用方法浅析
2017/05/20 Python
Python+OpenCV人脸检测原理及示例详解
2020/10/19 Python
python中退出多层循环的方法
2018/11/27 Python
Python爬虫实现的根据分类爬取豆瓣电影信息功能示例
2019/09/15 Python
Python 判断时间是否在时间区间内的实例
2020/05/16 Python
基于pytorch中的Sequential用法说明
2020/06/24 Python
GitHub上值得推荐的8个python 项目
2020/10/30 Python
详解python百行有效代码实现汉诺塔小游戏(简约版)
2020/10/30 Python
html5教程实现Photoshop渐变色效果
2013/12/04 HTML / CSS
localStorage、sessionStorage使用总结
2017/11/17 HTML / CSS
自我评价范文
2013/12/22 职场文书
中学生学雷锋演讲稿
2014/04/26 职场文书
倡导文明标语
2014/06/16 职场文书
个人党性分析总结
2015/03/05 职场文书
2015年材料员工作总结
2015/04/30 职场文书
2016十一国庆节感言
2015/12/09 职场文书
心理学培训心得体会
2016/01/22 职场文书