python之八大排序算法及时间复杂度

1.选择排序   O(n^2)

import json
def selete_sort(alist):
    for i in range(len(alist) - 1):
        for j in range(i+1, len(alist)):
            if alist[i] > alist[j]:
                alist[i], alist[j] = alist[j], alist[i]
            else:
                continue
    return alist
if __name__ == '__main__':
    list = input()
    alist = json.loads(list)  # 字符串形式list转list类型
    print(selete_sort(alist))

2.冒泡排序 O(n^2)

import json
def bubble_sort(alist):
    for i in range(len(alist)):
        for j in (0,len(alist)-i-1):
            if alist[j]>alist[j+1]:
                alist[j],alist[j+1]=alist[j+1],alist[j]
            else:
                break
        return alist
if __name__=="__main__":
    list=input()
    alist=json.loads(list)
    print(bubble_sort(alist))

3.插入排序  O(n^2)

import json
def insert_sort(alist):
    # 遍历所有数组元素
    for i in range(1,len(alist)):
        key=alist[i]
        j=i-1
        while j>=0:
            if alist[j] >key:
                alist[j+1] = alist[j]
                j-=1
            else:
                break
        alist[j+1]=key
    return alist
if __name__=="__main__":
    list=input()
    alist=json.loads(list)
    print(insert_sort(alist))

4.快速排序 O(n*log(n))

import json
def quick_sort(alist,start,end):
    if start>=end:
        return alist
    key=alist[start]
    left=start
    right=end
    while left=key:
             right-=1
       alist[left]=alist[right]
       while left

5.归并排序 O(n*log(n))

import json
def merge_sort(alist):
    if len(alist) <= 1:
        return alist
    num = len(alist) // 2
    left = merge_sort(alist[:num])
    right = merge_sort(alist[num:])
    return merge(left, right)
def merge(left, right):
    l=0
    r=0
    result = []
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result
if __name__=="__main__":
    list=input()
    alist=json.loads(list)
    print(merge_sort(alist))

6.希尔排序 O(n*log(n))~O(n^2)

import json
def shell_sort(alist):
    step=len(alist)//2
    while step>0:
        for i in range(step,len(alist)):
            while i>=step and alist[i-step]>alist[i]:
                alist[i],alist[i-step]=alist[i-step],alist[i]
                i-=step
        step=step//2
    return alist
if __name__=="__main__":
    list=input()
    alist=json.loads(list)
    print(shell_sort(alist))

7.堆排序 O(n*log(n))

import json
def build_heap(alist):
    for i in range(len(alist)-1,-1,-1):
        adjust_heap(alist,len(alist),i)
def adjust_heap(alist,heap_size,index):
    left_child=2*index+1
    right_child=2*index+2
    if left_childalist[index]:
        largest=left_child
    else:
        largest=index
    if right_childalist[largest]:
        largest=right_child
    if largest!=index:
        alist[index],alist[largest]=alist[largest],alist[index]
        adjust_heap(alist,heap_size,largest)
def heap_sort(alist):
    build_heap(alist)
    heap_size=len(alist)
    for i in range(len(alist)-1,0,-1):
        alist[i],alist[0]=alist[0],alist[i]
        heap_size-=1
        adjust_heap(alist,heap_size,0)
    return alist
if __name__=='__main__':
    list=input()
    alist=json.loads(list)
    print(heap_sort(alist))

8.基数排序

import json
def radix_sort(alist):
    i = 0
    max_num = max(alist)
    j = len(str(max_num))
    while i < j:
        bucket_list =[[] for _ in range(10)]
        for x in alist:
            bucket_list[int(x / (10**i)) % 10].append(x)
        alist.clear()
        for x in bucket_list:
            for y in x:
                alist.append(y)
        i += 1
    return alist
if __name__=='__main__':
    list=input()
    alist=json.loads(list)
    print(radix_sort(alist))