python排序算法的几种实现

#1、冒泡排序
def bubble_sort(arr):
    n=len(arr)
    for i in range(n):
        for j in range(n-i-1):
            if arr[j]>arr[j+1]:
                arr[j],arr[j+1]=arr[j+1],arr[j]
    return arr
a=[1,4,7,3,2,24,33]
sorted_list=bubble_sort(a)
print(sorted_list)
                
#2、选择排序
def select_sort(arr):
    n=len(arr)
    for i in range(n):
        min_idx=i
        for j in range(i+1,n):
            if arr[min_idx]>arr[j]:
                min_idx=j
        arr[i],arr[min_idx]=arr[min_idx],arr[i]
    return arr
b=[9,34,1,5,8,8]
sorted_list=select_sort(b)
print(sorted_list)
          
#3、插入排序
def insert_sort(arr):
    n=len(arr)
    for i in range(1,n):
        temp=arr[i]
        j=i-1
        while j>=0 and temp<arr[j]:
            arr[j+1]=arr[j]
            j-=1
        arr[j+1]=temp
    return arr
c=[9,34,1,5,8,33,2,8]
sorted_list=insert_sort(c)
print(sorted_list)
#4、归并排序
def merge_sort(arr):
    #不断递归调用自己一直到拆分成单个元素的时候就返回这个元素，不再拆分
    if len(arr)==1:
        return arr
    #取拆分的中间位置
    mid=len(arr)//2
    #拆分过后左右两侧子串
    left=arr[:mid]
    right=arr[mid:]
     #对拆分过后的左右再拆分 一直到只有一个元素为止
    #最后一次递归时候ll和lr都会接到一个元素的列表
    # 最后一次递归之前的ll和rl会接收到排好序的子序列
    #pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
    l1=merge_sort(left)
    r1=merge_sort(right)
     # 我们对返回的两个拆分结果进行排序后合并再返回正确顺序的子列表
    # 这里我们调用拎一个函数帮助我们按顺序合并ll和lr
    return merge(l1,r1)
def merge(left,right):
    # 从两个有顺序的列表里边依次取数据比较后放入result
    # 每次我们分别拿出两个列表中最小的数比较，把较小的放入result
    result=[]
    while len(left)>0 and len(right)>0:
    #为了保持稳定性，当遇到相等的时候优先把左侧的数放进结果列表，因为left本来也是大数列中比较靠左的
        if left[0]<=right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    #while循环出来之后 说明其中一个数组没有数据了，我们把另一个数组添加到结果数组后面
    result+=left
    result+=right
    return result
d=[9,78,5,3,2,1,4,7,9]
sorted_list=merge_sort(d)
print(sorted_list)   
    
#5\快速排序
def quick_sort(arr,start,end):
    # 递归的退出条件
    if start>=end:
        return 
    # 设定起始元素为要寻找位置的基准元素
    mid=arr[start]
    # low为序列左边的由左向右移动的游标
    low=start
    # high为序列右边的由右向左移动的游标
    high=end
    while low<high:
        # 如果low与high未重合，high指向的元素不比基准元素小，则high向左移动
        while low<high and arr[high]>=mid:
            high-=1
     # 将high指向的元素放到low的位置上
        arr[low]=arr[high]
        # 如果low与high未重合，low指向的元素比基准元素小，则low向右移动
        while low<high and arr[low]<mid:
            low+=1
            # 将low指向的元素放到high的位置上
        arr[high]=arr[low]
    # 退出循环后，low与high重合，此时所指位置为基准元素的正确位置
    # 将基准元素放到该位置
    arr[low]=mid
    # 对基准元素左边的子序列进行快速排序
    quick_sort(arr,start,low-1)
    # 对基准元素右边的子序列进行快速排序
    quick_sort(arr,low+1,end)
alist = [54,26,93,17,77,31,44,55,20]
quick_sort(alist,0,len(alist)-1)
print(alist)
      
#6\希尔排序
def shell_sort(arr):
    n=len(arr)
    dist=n//2
    while dist>0:
        for i in range(dist,n):
            temp=arr[i]
            j=i
            while j>=dist and temp<arr[j-dist]:
                arr[j]=arr[j-dist]
                j=j-dist
            arr[j]=temp
        dist=dist//2
    return arr
blist=[23,1,3,4,77,2,3,1,0]
shell_sort(blist)
print(blist)

#6\堆排序
def heapify(arr,n,i):
    largest=i
    l=2*i+1
    r=2*i+2
    if l<n and arr[i]<arr[l]:
        largest=l
    if r<n and arr[largest]<arr[r]:
        largest=r
    if largest!=i:
        arr[i],arr[largest]=arr[largest],arr[i]
        heapify(arr,n,largest)
def heap_sort(arr):
    n=len(arr)
    #创建大顶堆
    for i in range(n,-1,-1):
        heapify(arr,n,i)
    #一个个交换元素
    for i in range(n-1,0,-1):
        arr[i],arr[0]=arr[0],arr[i]
        heapify(arr,i,0)
clist=[12,2,1,34,7,4]
heap_sort(clist)
print(clist)