用Python实现常见排序算法
最简单的排序有三种:插入排序,选择排序和冒泡排序。这三种排序比较简单,它们的平均时间复杂度均为O(n^2),在这里对原理就不加赘述了。贴出来源代码。
插入排序:
def insertion_sort(sort_list):
iter_len = len(sort_list)
if iter_len < 2:
return sort_list
for i in range(1, iter_len):
key = sort_list[i]
j = i - 1
while j >= 0 and sort_list[j] > key:
sort_list[j+1] = sort_list[j]
j -= 1
sort_list[j+1] = key
return sort_list
冒泡排序:
def bubble_sort(sort_list):
iter_len = len(sort_list)
if iter_len < 2:
return sort_list
for i in range(iter_len-1):
for j in range(iter_len-i-1):
if sort_list[j] > sort_list[j+1]:
sort_list[j], sort_list[j+1] = sort_list[j+1], sort_list[j]
return sort_list
选择排序:
def selection_sort(sort_list):
iter_len = len(sort_list)
if iter_len < 2:
return sort_list
for i in range(iter_len-1):
smallest = sort_list[i]
location = i
for j in range(i, iter_len):
if sort_list[j] < smallest:
smallest = sort_list[j]
location = j
if i != location:
sort_list[i], sort_list[location] = sort_list[location], sort_list[i]
return sort_list
平均时间复杂度为O(nlogn)的算法有:归并排序,堆排序和快速排序。
#快排
def quickSort(lists):
if len(lists)<=1:
return lists
pivot = lists.pop()
left = []
right = []
for i in lists:
if i<pivot:
left.append(i)
else:
right.append(i)
return quickSort(left)+[pivot]+quickSort(right)
#归并排序
def mergesort(lists):
if len(lists)<=1:
return lists
mid = int(len(lists)/2)
left = lists[:mid]
right = lists[mid:]
mergesort(left)
mergesort(right)
return merge(left,right)
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
while(i<len(left)):
result.append(left[i])
i+=1
while(j<len(right)):
result.append(right[j])
j+=1
return result
#排序算法集合
import random
#冒泡排序
def BubbleSort(lists):
for i in range(0,len(lists)):
for j in range(0,len(lists)-1-i):
if lists[j]>lists[j+1]:
lists[j],lists[j+1] = lists[j+1],lists[j]
return lists
#选择排序
def selectionSort(lists):
for i in range(len(lists)):
min = i
for j in range(i+1,len(lists)):
if lists[j]<lists[min]:
min = j
if min != i:
lists[min],lists[i] = lists[i],lists[min]
return lists
#插入排序
def insertSort(lists):
for i in range(1,len(lists)):
key = lists[i]
j = i-1
while j>=0 and key<lists[j]:
lists[j+1] = lists[j]
j -= 1
lists[j+1]=key return lists
#希尔排序
def shellSort(lists):
count = len(lists)
step = 2
group = int(count/step)
while group>0:
for i in range(group):
j = i+group
while j<count:
key = lists[j]
k = j-group
while k>=0:
if key<lists[k]:
lists[k+group]=lists[k]
lists[k] = key
k -= group
j+=group
group = int(group/2)
return lists
#快排
def quickSort(lists):
if len(lists)<=1:
return lists
pivot = lists.pop()
left = []
right = []
for i in lists:
if i<pivot:
left.append(i)
else:
right.append(i)
return quickSort(left)+[pivot]+quickSort(right)
#归并排序
def mergesort(lists):
if len(lists)<=1:
return lists
mid = int(len(lists)/2)
left = lists[:mid]
right = lists[mid:]
left = mergesort(left)
right = mergesort(right)
return merge(left,right)
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
while(i<len(left)):
result.append(left[i])
i+=1
while(j<len(right)):
result.append(right[j])
j+=1
return result
#归并排序
def mergeSort(lists): mid = int(len(lists)/2)
left,right = lists[:mid],lists[mid:]
if len(left)>1:left = mergeSort(left)
if len(right)>1:right = mergeSort(right)
res = []
# while left and right:
# if left[-1]>=right[-1]:
# res.append(left.pop())
# else:
# res.append(right.pop())
# res.reverse()
#return (left or right) + res
while left and right:
if left[0]<=right[0]:
res.append(left.pop(0))
else:
res.append(right.pop(0))
return res+(left or right)
def adjust_heap(lists,i,size):
lchild = 2*i+1
rchild = 2*i+2
max = i
if i<size/2:
if lchild<size and lists[lchild]>lists[max]:
max = lchild
if rchild>size and lists[rchild]>lists[max]:
max = rchild
if max != i:
lists[max],lists[i] = lists[i], lists[max]
adjust_heap(lists,max,size)
def build_heap(lists,size):
for i in range(0,int(size/2))[::-1]:
adjust_heap(lists,i,size)
def heap_sort(lists):
size = len(lists)
build_heap(lists,size)
for i in range(0,size)[::-1]:
lists[0],lists[i] = lists[i],lists[0]
adjust_heap(lists,0,i)
return lists if __name__ =='__main__':
lists = [random.randint(1,20) for n in range(10)]
#print(lists)
#print(sorted(lists))
#print(lists)
#print(BubbleSort(lists))
#print(lists)
#print(selectionSort(lists))
#print(lists)
#print(insertSort(lists))
#print(lists)
#print(shellSort(lists))
#print(lists)
#print(mergesort(lists))
#print(lists)
#print(quickSort(lists))
#print(lists)
#print(mergeSort(lists))
print(lists)
print(heap_sort(lists))
用Python实现常见排序算法的更多相关文章
- python 的常见排序算法实现
python 的常见排序算法实现 参考以下链接:https://www.cnblogs.com/shiluoliming/p/6740585.html 算法(Algorithm)是指解题方案的准确而完 ...
- python实现常见排序算法
#coding=utf-8from collections import deque #冒泡排序def bubblesort(l):#复杂度平均O(n*2) 最优O(n) 最坏O(n*2) for i ...
- 常见排序算法-Python实现
常见排序算法-Python实现 python 排序 算法 1.二分法 python 32行 right = length- : ] ): test_list = [,,,,,, ...
- python常见排序算法解析
python——常见排序算法解析 算法是程序员的灵魂. 下面的博文是我整理的感觉还不错的算法实现 原理的理解是最重要的,我会常回来看看,并坚持每天刷leetcode 本篇主要实现九(八)大排序算法 ...
- python——常见排序算法解析
算法是程序员的灵魂. 下面的博文是我整理的感觉还不错的算法实现 原理的理解是最重要的,我会常回来看看,并坚持每天刷leetcode 本篇主要实现九(八)大排序算法,分别是冒泡排序,插入排序,选择排序, ...
- 常见排序算法(附java代码)
常见排序算法与java实现 一.选择排序(SelectSort) 基本原理:对于给定的一组记录,经过第一轮比较后得到最小的记录,然后将该记录与第一个记录的位置进行交换:接着对不包括第一个记录以外的其他 ...
- Python实现各种排序算法的代码示例总结
Python实现各种排序算法的代码示例总结 作者:Donald Knuth 字体:[增加 减小] 类型:转载 时间:2015-12-11我要评论 这篇文章主要介绍了Python实现各种排序算法的代码示 ...
- JS常见排序算法
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...
- JavaScript版几种常见排序算法
今天发现一篇文章讲“JavaScript版几种常见排序算法”,看着不错,推荐一下原文:http://www.w3cfuns.com/blog-5456021-5404137.html 算法描述: * ...
随机推荐
- [Linux]Vim的安装及使用
1.安装:$sudo apt-get install vim 2.查看Vim所在路径$whereis vim 3.启动Vim $'/usr/bin/vim.tiny' 4. 退出Vim窗口:Ctrl ...
- Android Camera拍照 压缩
http://www.linuxidc.com/Linux/2014-12/110924.htm package com.klp.demo_025; import java.io.ByteArrayI ...
- MFC笔记
一.Win32基本程序概念 所有的windows程序都必须载入windows.h MFC程序都有一个Stdafx.h文件,它载入了MFC框架必须的文件. Windows程序以消息为基础,以事件驱动之. ...
- socket+网路编程
1.网络编程: 通过某种计算机语言来实现不同设备间的资源共享和信息传递.计算机网络的创造可能比计算机本身意义更重大!!!(否则,你只能玩单机版游戏 OSI模型 OSI模型定义了不同计算机互联的标准,是 ...
- 需求分析Point
1.码段的查询结果的汇总值计算有问题.被删除的是否还算是被使用范围内呢?现在是即使废弃了也算使用的.这就有范围和重叠的问题,需要识别这种集合关系的数据好概念,并搞清楚他们的关系和概念.
- 从UI Automation看Windows平台自动化测试原理
前言 楼主在2013年初研究Android自动化测试的时候,就分享了几篇文章 Android ViewTree and DecorView Android自动化追本溯源系列(1): 获取页面元素 An ...
- 掌握C++基础
以下是笔者在ubuntu系统下编译运行通过的一些反应c++基础特性的例子,包括类,结构体,构造函数,析构函数,函数的重载,this指针,类的继承,虚函数,函数的覆盖和隐藏等.(由于格式问题代码中的乱码 ...
- 总结Web应用中基于浏览器的安全漏洞
1.浏览器缓存 每次打开一个网站,网页的内容会缓存到用户的机器中.如果这些内容在其他网页中需要重新加载,浏览器加载的是缓存,而不是再次下载内容.如果一些Web应用商店以及显示用户敏感信息(比 ...
- 2016 年开发者应该掌握的十个 Postgres 技巧
[编者按]作为一款开源的对象-关系数据库,Postgres 一直得到许多开发者喜爱.近日,Postgres 正式发布了9.5版本,该版本进行了大量的修复和功能改进.而本文将分享10个 Postgres ...
- codeforces D. Count Good Substrings
http://codeforces.com/contest/451/problem/D 题意:给你一个字符串,然后找出奇数和偶数长度的子串的个数,这些字串符合,通过一些连续相同的字符合并后是回文串. ...