排序算法（python实现）

1、插入排序

基本思想：

将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

算法分析：

其中括号里面为已经排好序的序列

初始数组：【2 】 5 1 4 8 9 7 6 3 0

一次排序：【2 5 】 1 4 8 9 7 6 3 0

二次排序：【1 2 5 】 4 8 9 7 6 3 0

三次排序：【1 2 4 5】 8 9 7 6 3 0

四次排序：【1 2 4 5 8 】 9 7 6 3 0

五次排序：【1 2 4 5 8 9 】 7 6 3 0

六次排序：【1 2 4 5 7 8 9 】 6 3 0

七次排序：【1 2 4 5 6 7 8 9 】 3 0

八次排序：【1 2 3 4 5 6 7 8 9 】 0

九次排序：【0 1 2 3 4 5 6 7 8 9 】 0

代码：

#coding:utf-8
#代码调试环境为python 3.4

def insert_sort(mylist):
if len(mylist)==0:
return mylist
for i in range(1,len(mylist)):
j=i
temp=mylist[i]
while j>0 and mylist[j-1] > temp:
mylist[j] = mylist[j-1]
j -=1

if __name__=='__main__':
mylist=[81,94,11,96,12,35,17,95,28,58,41,75,15]
insert_sort(mylist)
print(mylist)

2、Shell排序

基本思想：

它通过比较相距一定间隔的元素来工作，各趟比较所用的距离随着算法的进行而减小，直到只比较相邻元素的最后一趟排序为止。

算法分析：

shell排序使用一个序列h1,h2,...ht叫做增量排序。只要h1=1任何增量序列都是可行的。例如下面的例子就是以（1,3,5）为增量序列对原始序列排序之后的结果：

- 初始数组： 81, 94, 11, 96, 12, 35, 17, 95, 28, 58, 41, 75, 15

- 增量5排序：35, 17, 11, 28, 12, 41, 75, 15, 96, 58, 81, 94, 95

- 增量3排序：28, 12, 11, 35, 15, 41, 58, 17, 94, 75, 81, 96, 95

- 增量1排序：11, 12, 15, 17, 28, 35, 41, 58, 75, 81, 94, 95, 96

代码：

#coding:utf-8
#代码调试环境为python 3.4

def shell_sort(mylist):
gap=len(mylist)//2
while gap>0:
for i in range(gap,len(mylist)):
j=i
temp=mylist[i]
while j>=gap and temp < mylist[j-gap]:
mylist[j]=mylist[j-gap]
j-=gap
mylist[j]=temp
gap//=2

if __name__=='__main__':
mylist=[81,94,11,96,12,35,17,95,28,58,41,75,15]
shell_sort(mylist)
print(mylist)

3、快速排序

基本思想：

快速排序算法可以分成下面四个简单的步骤

1. 如果S中元素个数是1或者0，则返回。

2. 取S中任一元素v，称之为枢纽元（pivot）

3. 将S-{v}（S中其余元素）划分成两个不相交的集合：

S1={x∈S−{v}|x≤v}和S2={x∈S−{v}|x≥v}

4. 返回{quick_sort(S1),v,quick_sort(S2)}

代码：

#coding:utf-8
#代码调试环境为python 3.4

def quick_sort(mylist):
if(len(mylist) < 2):
return
left = [x for x in mylist[1:] if x < mylist[0]]
right = [x for x in mylist[1:] if x >= mylist[0]]
quick_sort(left)
quick_sort(right)
mylist[:] = left + [mylist[0]] + right

if __name__=='__main__':
mylist=[81,94,11,96,12,35,17,95,28,58,41,75,15]
quick_sort(mylist)
print(mylist)

4、冒泡排序

基本思想：

冒泡排序算法的运作如下：（从后往前）

1. 从第一个元素开始比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 第一次比较完毕之后第一个元素应该会是最小的数。

3. 从第二个元素开始重复步骤一，这样第二大的元素就会排在第二位。

4. 每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码：

#coding:utf-8
#代码调试环境为python 3.4

def bubble_sort(mylist):
if(len(mylist) < 2):
return
for i in range(0,len(mylist)):
flag=0
j=len(mylist)-1
while j>i:
if mylist[j]<mylist[j-1]:
mylist[j],mylist[j-1]=mylist[j-1],mylist[j]
flag=1
j-=1
if flag==0:
return

if __name__=='__main__':
mylist=[81,94,11,96,12,35,17,95,28,58,41,75,15]
bubble_sort(mylist)
print(mylist)

5、归并排序

基本思想：

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

代码：

#coding:utf-8
#代码调试环境为python 3.4

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 merge_sort(mylist):
"""递归排序"""
if len(mylist)<2:
return mylist
mid=len(mylist)//2
left=merge_sort(mylist[:mid])
right=merge_sort(mylist[mid:])
return merge(left,right)

if __name__=='__main__':
mylist=[81,94,11,96,12,35,17,95,28,58,41,75,15]
result=merge_sort(mylist)
print(result)

代码下载地址

https://github.com/Zhanben/python/blob/master/Sort

参考资料

数据结构与算法分析（c++描述） Mark allen wesis