1.冒泡排序(从大到小):交换发生在内部循环

稳定的排序

冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2),空间复杂度为O(1)

冒泡排序的优化在于didswap变量 ,通过这个变量的设置,实现冒泡排序的最好时间复杂度是O(n)

#!usr/bin/python
arr=[1,2,3,4,5,6,7,8,67,5,64,43,546,56,76,34,657,34,45,56,23]
def BubbleSort(list):
for i in range(len(list)-1):
didswap = False
for j in range(len(list)-1-i):
if list[j]<list[j+1]:
list[j],list[j+1]=list[j+1],list[j]
didswap =True
if didswap == False:
return list
return list
print (BubbleSort(arr))

2.选择排序(从大到小):交换发生在外部循环

不稳定的排序

平均算法复杂度O(n2),最好算法复杂度O(n2),最坏的算法复杂度为O(n2),空间复杂度O(1)

#!usr/bin/python
def SelectSort(lists):
for i in range(len(lists)-1):
max=i
for j in range(i+1,len(lists)):
if lists[j]>lists[max]:
max=j
lists[max],lists[i]=lists[i],lists[max]
return lists lists=[2,3,4,65,7,6,5,5,6,7,8,6,4]
print SelectSort(lists)

3.插入排序(从大到小排序):

稳定的排序

平均复杂度O(n2),最好的时间复杂度O(n),最坏的算法复杂度O(n2),空间复杂度是O(1)

#!usr/bin/python
def InsertSort(lists):
for i in range(1,len(lists)):
key=lists[i]
j=i-1
while j>=0 and lists[j]<key:
lists[j+1]=lists[j]
j=j-1
lists[j+1]=key
return lists
arr=[2,3,4,5,6,8,7,5,6,7,6,4,5,6,7,8,7,5]
print InsertSort(arr)

4.归并排序(从大到小):归并排序的思想就是分而治之

归并排序是稳定

平均O(nlgn) 最好的时间复杂度是O(nlgn),最坏的时间复杂度是O(nlgn),空间复杂度是O(n)

#!usr/bin/python
def Merge(left,right):
i,j=0,0
result=[]
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 MergeSort(lists):
if len(lists)<2:
return lists
div = len(lists)/2
left=MergeSort(lists[0:div])
right=MergeSort(lists[div:])
return Merge(left,right) lists = [2,3,4,5,6,7,6,5,34,23,4,56,6,3,4,6]
print MergeSort(lists)

5.快速排序:(递归调用)

平均时间复杂度O(nlgn),平均时间复杂度O(nlgn),最坏的时间复杂度O(n2)

空间复杂度O(lgn)-Olg(n)

def QuickSort(myList,start,end):
#判断low是否小于high,如果为false,直接返回
if start < end:
i,j = start,end
#设置基准数
base = myList[i]
while i < j:
#如果列表后边的数,比基准数大或相等,则前移一位直到有比基准数小的数出现
while (i < j) and (myList[j] >= base):
j = j - 1
#如找到,则把第j个元素赋值给第个元素i,此时表中i,j个元素相等
myList[i] = myList[j]
#同样的方式比较前半区
while (i < j) and (myList[i] <= base):
i = i + 1
myList[j] = myList[i]
#做完第一轮比较之后,列表被分成了两个半区,并且i=j,需要将这个数设置回base
myList[i] = base #递归前后半区
QuickSort(myList, start, i - 1)
QuickSort(myList, j + 1, end)
return myList lists = [49,38,65,97,76,13,27,49]
print(QuickSort(lists,0,len(lists)-1))
print (lists)

7.堆排序(从大到小):第一步最小堆化;第二步建立最小堆;第三步堆排序

#!user/bin/python
def AjustHeap(lists,i,size):
min=i
left=2*i+1
right=2*i+2
if i < size/2:
if right < size and lists[min] > lists[right]:
min=right
if left < size and lists[min]>lists[left]:
min=left
if min!=i:
lists[i],lists[min]=lists[min],lists[i]
AjustHeap(lists,min,size)
def BuildHeap(lists,size):
for i in range(0,(size/2))[::-1]:
AjustHeap(lists,i,size)
def HeapSort(lists):
size=len(lists)
BuildHeap(lists,size)
for i in range(0,size)[::-1]:
lists[i],lists[0]=lists[0],lists[i]
AjustHeap(lists,0,i)
return lists
arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]
print HeapSort(arr)

6.希尔排序(从大到小):(插入排序的一种)

#!user/bin/python
def ShellSort(lists):
step=len(lists)/2
while (step>=1):#step终止循环为1
for i in range(step,len(lists)):#没一次step对应很多个新列表
while(i>=step and lists[i] > lists[i-step]):#每个列表进行排序
lists[i],lists[i-step]=lists[i-step],lists[i]
i=i-step
step=step/2
return lists
arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]
print ShellSort(arr)

8.计数排序:

8大排序之Python实现 冒泡排序优化的更多相关文章

  1. Javascript中,实现十大排序方法之一(冒泡排序及其优化设想)

    冒泡排序的Javascript实现 首先定义一个取值范围在(0~100000)之间的随机值的长度为10万的数组, function bubbleSort(arr) { console.time('冒泡 ...

  2. 【程序员笔试面试必会——排序①】Python实现 冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序、希尔排序

    最近在准备笔试题和面试题,把学到的东西整理出来,一来是给自己留个笔记,二来是帮助大家学习. 题目: 给定一个int数组A及数组的大小n,请返回排序后的数组. 测试样例:  输入:[1,2,3,5,2, ...

  3. 程序员必知的8大排序(三)-------冒泡排序,快速排序(java实现)

    程序员必知的8大排序(一)-------直接插入排序,希尔排序(java实现) 程序员必知的8大排序(二)-------简单选择排序,堆排序(java实现) 程序员必知的8大排序(三)-------冒 ...

  4. python排序算法之一:冒泡排序(及其优化)

    相信冒泡排序已经被大家所熟知,今天看了一篇文章,大致是说在面试时end在了冒泡排序上,主要原因是不能给出冒泡排序的优化. 所以,今天就写一下python的冒泡排序算法,以及给出一个相应的优化.OK,前 ...

  5. 排序算法入门之冒泡排序及其优化(java实现)

    冒泡排序思想(从小到大): 比较相邻两个元素,如果第一个元素比第二个元素大,就交换他们的位置.第一趟,从第一个元素开始,第一个元素和第二个元素比较,如果第一个元素比第二个元素大,则交换位置:接下来比较 ...

  6. Python实现八大排序(基数排序、归并排序、堆排序、简单选择排序、直接插入排序、希尔排序、快速排序、冒泡排序)

    目录 八大排序 基数排序 归并排序 堆排序 简单选择排序 直接插入排序 希尔排序 快速排序 冒泡排序 时间测试 八大排序 大概了解了一下八大排序,发现排序方法的难易程度相差很多,相应的,他们计算同一列 ...

  7. 一篇夯实一个知识点系列--python实现十大排序算法

    写在前面 排序是查找是算法中最重要的两个概念,我们大多数情况下都在进行查找和排序.科学家们穷尽努力,想使得排序和查找能够更加快速.本篇文章用Python实现十大排序算法. 干货儿 排序算法从不同维度可 ...

  8. [ 转载 ] js十大排序算法:冒泡排序

    js十大排序算法:冒泡排序  http://www.cnblogs.com/beli/p/6297741.html

  9. 使用 js 实现十大排序算法: 冒泡排序

    使用 js 实现十大排序算法: 冒泡排序 冒泡排序 refs xgqfrms 2012-2020 www.cnblogs.com 发布文章使用:只允许注册用户才可以访问!

随机推荐

  1. docker 容器内启动 sshd 启动报错

    创建容器设置密码 安装 openssh-server 启动出错 在容器内 使用 /usr/sbin/sshd -d 启动报错? [root@9d41c7f36c5e tmp]# /usr/sbin/s ...

  2. Restful API学习Day5 - DRF之限制 分页 解析器和渲染器

    参考文档: Django REST framework基础:认证.权限.限制 Django REST framework基础:分页 Django REST framework基础:解析器和渲染器 一. ...

  3. 源码解读-文件上传angularFileUpload1

    angular-file-upload 1.文件上传模块的引入就不赘述,简单准备 2.初始化组件并绑定change事件 3.监听用户选择文件FileItem(change事件),push进文件数组qu ...

  4. jq的css方法

    读属性: $(selector).css(name) 设置属性: 法一: $(selector).css(name,value) 法二: $(selector).css(name,function(i ...

  5. 【tmos】如何在Interceptor拦截器中注入其他数据

    光是这样是获取不到weixinConfig内容的 public class WebLoginInterceptor implements HandlerInterceptor { @Autowired ...

  6. react实现极简搜索框效果

    hover.css内容 * { margin:; padding:; } li.hover { background: #ccc; color: darkgreen; } js内容 import Re ...

  7. 30个极大提高开发效率的vscode插件

    参考链接:https://blog.fundebug.com/2018/07/24/vs-extensions/

  8. 解决 Qt5 报错 This application failed to start because it could not find or load the Qt platform plugin

    QT为了简化生成发布版本,特别提供了工具 "windeplayqt.exe",这个工具在 "...\Qt5.8.0\5.8\msvc2015_64\bin"的目 ...

  9. CentOS 7 安装配置 Vsftpd

    https://blog.imzhengfei.com/centos-an-zhuang-pei-zhi-vsftpd/ vsftpd 是“very secure FTP daemon”的缩写,是一款 ...

  10. Python学习笔记-数字类型

    如何定义一个数字类型 定义var1为一个INT类型,所以在5/3 输出的是 1. var1 = 5 var1=var1/3 print var1 定义var1为一个INT类型,因为var1是INT类型 ...