排序算法（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排序使用一个序列$h_1,h_2,...h_t$叫做增量排序。只要$h_1=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中其余元素）划分成两个不相交的集合：
$S_1=\{x\in S-\{v\}|x\leq v\}$和$S_2=\{x\in S-\{v\}|x\geq v\}$
4. 返回{quick_sort($S_1$),v,quick_sort($S_2$)}

代码：

#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