排序算法python实现

#冒泡排序
def bubble_sort(lists):
    # 冒泡排序
    #如果i > j就交换 就可以保证i的值是最小的
    count = len(lists)
    for i in range(0, count):
        for j in range(i + 1, count):
            if lists[i] > lists[j]: #注意这里是i 与j 比较 这样就可以把最小的值放到最前面
                lists[i], lists[j] = lists[j], lists[i]
    return lists
def my_bubble_sort():
    #按照c的方法实现 一样的效果
    a = [9, 10, 5, 6, 1, 5, 9, 12, 9, 5]
    len = len(a)
    for i in range(len - 1):
        for j in range(len - i - 1):
            if a[j] > a[j + 1]:
                a[j], a[j + 1] = a[j + 1], a[j]
    print(a)
#快速排序
def quick_sort(list,left,right):  #right=len-1
    if left>=right:
        return list
    key=list[left]
    #这里记得把left right存起来 因为后面会改变其值 而递归调用会用到这个没有改变的值
    low=left
    high=right

    while left<right:
        while left < right and list[right] >= key:   #这里必须加等号 否则会死循环
            right -= 1
        list[left] = list[right]

        while left < right and list[left] <= key:
            left += 1
        list[right] = list[left]
    list[right]=key

    quick_sort(list,low,left-1)
    quick_sort(list,left+1,high)

    return  list
#堆排序的实现  完全按照c++的算法写的
#完成对一个父节点位置的放置 放置为还满足最小堆
def adjust_heap(list,p,len): #p为父节点 len为长度
    lchild=2*p+1   #左孩
    currentp=list[p]   #保存父节点 避免被替换  方便比较
    while lchild<len:
        if lchild+1<len and list[lchild]>list[lchild+1]  :
            lchild+=1
        if currentp>list[lchild]:
            list[p]=list[lchild]
            p=lchild   #更新父节点
            lchild=2*p+1  #更新子节点
        else:
            break   #这个不能省去
    list[p]=currentp  #把父节点放在正确的位置上
    return list
def heap_sort(list,len):
    #初始化堆为最小堆
    for i in range(len//2)[::-1]:  #加这个就可以逆序 从最后一个父节点开始
        list=adjust_heap(list,i,len)
    print(list)
    #交换首尾值   这样得到的序列为逆序 及最小堆 得到的结果是从大到小的排序
    for j in range(len)[::-1]:
        list[0],list[j]=list[j],list[0]
        list=adjust_heap(list,0,j)
    print(list)

#插入排序
def insert_sort(list):
    for i in range(len):
        temp=a[i]
        j=i-1;
        while j>=0:
            if list[j]>temp:
# 每次循环的时候都把j+1 和 j都填充上去，j+1填j  j填temp
#如果不满足temp该放的位置 则下次的时候j会被j-1覆盖掉 直到正确的位置
                list[j+1]=list[j]
                list[j]=temp
            j-=1
    return list

#希尔排序
def shell_sort(list):
    gap=len//2
    while gap>=1:
        for i in range(gap):
            j=i+gap
            while j<len:
                k=j-gap
                key=list[j]
                while k>=0:
                    if list[k]>key:
                        list[k+gap]=list[k]
                        list[k]=key
                    k-=gap
                j+=gap
        gap//=2
    return list

#归并排序
def merge(a,b):  #归并
    i,j=0,0
    c=[]
    while i<len(a) and j<len(b):
        if a[i]<b[j]:
          c.append(a[i]) #这里得用append函数  因为c声明的时候没有声明数量
          i+=1
        else:
          c.append(b[j])
          j+=1
    c+=a[i:]   #把剩余没有比较的加进去
    c+=b[j:]
    return  c
def merge_sort(list):
    if len(list)<=1:   #用来终止递归
        return list

    d=len(list)//2
    a=list[:d]      #不断分为两部分
    b=list[d:]
    a=merge_sort(a)    #递归 并返回结果
    b=merge_sort(b)
    return merge(a,b)

#桶排序 没有采用链表，采用了较多的桶  相同的数放在一个桶中
def bucket_sort(data):
    buckets=[0]*(max(data)-min(data)+1)
    for i in data:
        buckets[i]+=1
    j=0

    for i in range(len(buckets)):
        while buckets[i]!=0:
            data[j] =i
            buckets[i]-=1
            j+=1
    return data

#基数排序  与c++一致 在每一位的排序时用桶排序
#import math  import copy
def radix_sort(data):
    result=[0]*len(data)
    k=math.ceil(math.log(max(data),10))
    for i in range(k):   #循环每一位
        count = [0] * 10   #不要忘记了每次都把count清零  否则会下标越界
        for j in data:   #计数
            d=(j//(10**i))%10
            count[d]+=1
        for j in range(1,10):  #计算位置
            count[j]+=count[j-1]
        for j in data[::-1]:
            d = (j // (10 ** i)) % 10
            result[count[d]-1]=j    #关键的一步   排序
            count[d]-=1
            data=copy.deepcopy(result)  #采用深复制
    return data

#选择排序
def select_sort(data):
    n=len(data)
    for i in range(n):
        p=data[i]
        index=i
        for j in range(i+1,n):
            if(p>data[j]):
                index=j
                p=data[j]
        if index!=i:
            data[i],data[index]=data[index],data[i]
    return data

#计数排序和桶排序一致（和不适用链表的桶排序）

2017-10-16

排序算法的python实现 初版 自己写的 参考的c++ 不太优化