排序算法（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