python实现多种排序算法

#冒泡排序的python实现
def bubble_sort(lst):
    if not lst:
        return []
    elif len(lst)==1:
        return lst
    else:
        for i in range(len(lst)):
            for j in range(len(lst)-1,i,-1):
                if lst[j]<lst[j-1]:
                    lst[j],lst[j-1]=lst[j-1],lst[j]
        return lst
if __name__=="__main__":
    array2=[5,3,8,7,6,9,-1]
    array2=bubble_sort(array2)

#简单选择排序的python实现
def Select_sort(lst):
    if not lst:
        return []
    elif len(lst)==1:
        return lst
    else:
        for i in range(0,len(lst)):
            mindex=i
            for j in range(i+1,len(lst)):
                if lst[j]<lst[mindex]:
                    mindex=j
            if mindex!=i:
                lst[mindex],lst[i]=lst[i],lst[mindex]
        return lst  

#插入排序 

def insert_sort(lst):
    if not lst:
        return []
    elif len(lst)==1:
        return lst
    else:
        for i in range(1,len(lst)):
            key=lst[i]
            j=i-1
            while j>=0:
                if lst[j]>key:
                    lst[j+1]=lst[j]
                    lst[j]=key
                j-=1
        return lst

##希尔排序(缩小增量排序）把记录按下标的一定增量分组，
#对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。)
def shell_sort(lst):
    step=len(lst)//2
    while step>0:
        for i in range(step,len(lst)):
            # 类似插入排序, 当前值与指定步长之前的值比较, 符合条件则交换位置
            while i>=step and lst[i]<lst[i-step]:
                lst[i],lst[i-step]=lst[i-step],lst[i]
                i-=step
        step=step//2
    return lst           

##python实现堆排序
#python中提供了堆这种数据结构，可以直接使用heap中的heappush方法来建立堆，使用heappop来弹出堆中的最小元素。

方法1：

from heapq import *
def heapsort(lista):
    h=[]
    for i in range(len(lista)):
        heappush(h,lista[i])
        print (h)
    for i in range(len(h)):
        lista[i]=heappop(h)
        print (lista)
    return lista

方法2：

def heapsort2(lista):
    n=len(lista)
    for i in range((n-1)//2,-1,-1):
        headadjust(lista,i,n-1)
    for i in range(n-1,-1,-1):
        lista[i],lista[0]=lista[0],lista[i]
        headadjust(lista,0,i-1)
    return lista
def headadjust(lista,s,end):
    i=2*s+1
    temp=lista[s]
    while (i<=end):
        if i+1<=end and lista[i+1]>lista[i]:
            i=i+1
        if lista[i]<=temp:
            break
        lista[s]=lista[i]
        s=i

#快速排序
def quick_sort(lst,left,right):
    if left>=right:
        return
    q=partition(lst,left,right)
    quick_sort(lst,left,q-1)
    quick_sort(lst,q+1,right)
    return lst
def partition(lst,left,right):
    low=left
    high=right
    key=lst[low]
    while left<right:
        while left<right and key<lst[right]:
            right-=1
        lst[left]=lst[right]
        while left<right and key>=lst[left]:
            left+=1
        lst[right]=lst[left]
    lst[right]=key
    return left
        i=s*2+1
    lista[s]=temp

#堆排序
def headsort(lst):
    n=len(lst)
    for i in range((n-1)//2,-1,-1):
        headadjust(lst,i,n-1)
    for i in range(n-1,-1,-1):
        lst[i],lst[0]=lst[0],lst[i]
        headadjust(lst,0,i-1)
    return lst
def headadjust(lst,s,end):
    i=2*s+1
    temp=lst[s]
    while (i<=end):
        if i+1<=end and lst[i+1]>lst[i]:
            i+=1
        if lst[i]<=temp:
            break
        lst[s]=lst[i]
        s=i
        i=s*2+1
    lst[s]=temp

#归并排序详解（python实现）采用了分治的方法
def merge_sort(lst):
    if len(lst)<=1:
        return lst
    mid=len(lst)//2
    left=merge_sort(lst[:mid])
    right=merge_sort(lst[mid:])
    return merge(left,right)
def merge(left,right):
    res=[]
    i,j=0,0
    while i<len(left) and j<len(right):
        if left[i]<right[j]:
            res.append(left[i])
            i+=1
        else:
            res.append(right[j])
            j+=1
    res+=left[i:]
    res+=right[j:]
    return res