Python实现十种经典排序算法

1、冒泡排序

基本思想：一次只比较两个元素，算法的时间复杂度为 $O(n^2)$

def bub_sort(lists):
    n = len(lists)
    for i in range(n):
        for j in range(n):
            if lists[j-1] > lists[j]:
                lists[j-1],lists[j] = lists[j],lists[j-1]
    return lists

2、插入排序

基本思想：将一个数据插入到已经排好序的数组中，算法的时间复杂度为 $O(n^2)$

def insert_sort(lists):
    size = len(lists)
    for i in range(1,size):
        pivot = lists[i]
        j = i-1
        while j >= 0:
            if lists[j] > pivot:
                lists[j+] = list[j]
                lists[j] = pivot
            j -= 1
    return lists

3、选择排序

基本思想：每次选择最小的元素放到当前位置

def select_sort(lists):
    n = len(lists)
    for i in range(n):
        for j in range(i:n):
            if lists[i] < lists[j]:
                lists[i],lists[j] = list[j],list[i]
    return lists

4、希尔排序

是插入排序的一种

def shell_sort(lists):
    n = len(lists)
    dist = n//2
    while dist > 0:
        for i in range(dist,n):
            temp = lists[i]
            j = i
            while j >= dist and temp < lists[j - dist]:
                lists[j] = lists[j - dist]
                j -= dist
            lists[j] = temp
        dist //= 2
    return lists

5、归并排序

基本思想：分而治之的思想，先把大的数组分为两个小规模的数组，把两个小数组分别排序，再组合。算法的时间复杂度 $O(nlogn)$

def merge_sort(lists):
    if len(lists) <=1:
        return lists
    mid = len(lists)//2
    left = merge_sort(lists[:mid])
    right = merge_sort(lists[mid:])
    return merge(left,right)
def mmerge(left,right):
    res = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            res.append(left[i])#append用于在列表末尾添加新内容
            i +=1
        else:
            res.append(right[j])
            j += 1
    res += left[i:]
    res += rught[j:]
    return res

6、堆排序

##堆排序
def heap_sort(lists):
    size = len(lists)
    build_heap(lists, size)
    for i in range(0, size)[::-1]:
        lists[0], list[i] = list[i], lists[0]
        adjust_heap(lists, 0, i)
    return lists

#堆调整
def adjust_heap(lists, i, size):
    lchild = 2 * i + 1
    rchild = 2 * i + 2
    maxi = i
    if lchild < size and lists[maxi] < lists[lchild]:
        maxi = lchild
    if rchild < size and lists[maxi] < lists[rchild]:
        maxi = rchild
    if maxi !=i:
    #在做了堆调整之后，做对调值操作
        lists[maxi],lists[i] = lists[i],lists[maxi]
        adjust_heap(lists, maxi, size)

#堆构建
def build_heap(lists,size):
    for i in range(0, int(size/2))[::-1]:
        adjust_heap(lists, i, size)

7、快速排序

基本思想：分而治之

def quick_sort(lists):
    less = []
    pivotlist = []
    more = []
    if len(lists) <= 1:
        return lists
    else:
        pivot = lists[0] #把第一个元素作为key
        for i in lists:
            if i < pivot:
                less.append(i)
            elif i > pivot:
                more.append(i)
            else:
                pivotlist.append(i)
        less = quick_sort(less)
        more = quick_sort(more)
    return less + pivotlist + more

def QuickSort(mylist,left,right):
    if left < right:
        i,j = left,right
        base = mylist[i]  #base作为基准数
        while (i < j):
            while (i < j) and (mylist[j] >= base):'''若列表后边的数比基准数大或相等，
                                                     则前移一位直到有比基准数小的数出现'''
                j = j - 1
            mylist[i] = mylist[j]#如找到，则把第j个元素赋值给第i个元素，此时列表中i,j的元素相等
            while (i < j) and (mylist[i] <= base):#同样的方式比较前半区
                i = i + 1
            mylist[j] = mylist[i]
        mylist[i] = base
        
        #递归前后半区
        QuickSort(mylist, left, i-1)
        QuickSort(mylist, j + 1, right)
    return mylist

8、计数排序

基本思想：对于某个元素a，检查有几位元素小于a记为i，然后把a放到序号为i的位置

def count_sort(a,k):#a为数组，k为max(a)
    n = len(a)
    b = [0 for i in range(n)] #设置输出序列，并初始化为0
    c = [0 for i in range(k+1)] #设置计数序列并初始化为0
    for j in a:
        c[j] = c[j] + 1
    for i in range(1, len(c)):
        c[i] = c[i] + c[i-1]
    for j in a:
        b[c[j] - 1] = j
        c[j] = c[j] - 1
    return b

9、桶排序

基本思想：把数组分为若干个等长区间，每个子数组各自排序，最后合并

def bucket_sort(a):
    buckets = [0] * ((max(a)-min(a))+1) #初始化桶元素为0
    for i in range(len(a)):
        buckets[a[i] - min(a)] +=1 #遍历数组a，在桶的相应位置累加值
        b = []
        for i in range(len(buckets)):
            if bucket[i] != 0:
                b += [i + min(a)] * buckets[i]
        return b

10、基数排序

基本思想：将待排序的数据按照位数切割成不同的数字，然后按每个位数分别比较

def radix_sort(list, d = 3): #默认三位数，可以自定义修改
    for i in range(d): #d轮排序
        s = [[] for k in range(10)] #因为每一位数字都是0-9，所以建10个桶
        for j in list:
            s[int(j / (10 ** i)) % 10].append(j)
        re = [a for b in s for a in b]
    return re