常见排序算法、时间复杂度、python代码实现

本文所有动态图都摘取自五分钟学算法公众号。
1.时间复杂度分为最优时间复杂度、最坏时间复杂度、平均时间复杂度。
2.由于最优时间复杂度和平均复杂度只能解决部分的情况，因此通常以最坏时间复杂度为评判标准。
3.时间复杂度的基本计算原则：

• 常数项视为常数
• 顺序结构：时间复杂度按加法计算
• 循环结构：时间复杂度按乘法计算
• 分支结构：时间复杂度取其中最大值
• 计算出最坏时间复杂度之后，将其中的常数项和系数全部忽略
  

冒泡排序

相邻的两个数字比较交换，每一轮确定一个数字
最坏时间复杂度：O(n^2)

def maopaosort(L):
    for i in range(len(L)):   # 确定交换的轮数
        for j in range(len(L)-i-1):  #表示交换数字的下标   最大为第一轮(数字总数-1)
            if L[j] >L[j+1]:
                L[j],L[j+1] = L[j+1],L[j]
    return L
list = [9,4,1,87,2]
print(maopaosort(list)

选择排序

从左到右，每一轮找到一个最小数字放置
最坏时间复杂度：O(n^2)

def selectsort(l):
    for i in range(len(l)-1):# 表示寻找最小值的次数 
        min = i              # 记录最小值下标
        for j in range(i+1,len(l)):#表示比较的数字，从第二个数字开始
            if l[min]>l[j]:
                l[min],l[j] = l[j],l[min]
    return l
list =[10,53,1,8,400,111,10]
print(selectsort(list))

插入排序

把第一个数字视为有序数列，从第二个开始逐个插入到有序数列的合适位置

def insertpaixu(l):
    n= len(l)
    for i in range(1,n):#控制次数，从第二个数字到最后一个数字 一共n-1次
        j = i   #j表示  右侧无序列表中第一个元素的下标
        while j>0:
            if l[j]<l[j-1]:
                l[j],l[j-1] = l[j-1],l[j]
                j-=1
            else:
                break
    return l
list = [1,12,78,48,3,6,7,9,2,5,4]
print(insertpaixu(list))

希尔排序

在插入排序的基础上，增加了间隔进行分组完成插入排序，不断缩小间隔再比较，直至间隔为0

def shellsort(l):
    n = len(l)
    gap = n//2   #python3中的n/2  结果是浮点数      n//2  结果是取得整数
    while gap>0: #这里控制gap的值，不断取半，直到取到1为最后一轮
        for i in range(gap,n): #这里控制循环次数， 从中线右侧的第一个交换数开始 直到数列最后一个
            j = i
            while j>0 and l[j]<l[j-gap]:
                l[j],l[j-gap] =l[j-gap],l[j]
                j -= gap
        gap = gap//2
    return l
list = [1,12,78,48,3,6,7,9,2,5,4]
print(shellsort(list))

快速排序

def quicksort(l,start,end):
	low = start
	high = end 
	mid = l[low]
	if start <= end:
		return
	while low<high:
		while low<high and l[high]>mid:
			high -= 1
		l[low] = l[high]
		while low<high and l[low]<=mid:
			low += 1
		l[high] = l[low]
	mid = l[low]
	quicksort(l,start,low-1)
	quicksort(l,low+1,end)
	
list = [1,12,78,48,3,6,7,9,2,5,4]
quicksort(list, 0, len(list)-1)
print(list)		 		

先将序列按照取半的方式进行，拆分，递归调用后形成单个序列，随后在组合序列的过程进行排序，输入到生成的新的序列中。

def merge_sort(alist):
    n = len(alist)
    if n <= 1:
        return alist
    mid = n//2
    l_list = merge_sort(alist[:mid])
    r_list = merge_sort(alist[mid:])
    #定义一个新的列表
    result = []
    l_cur, r_cur = 0, 0
    while l_cur < len(l_list) and r_cur < len(r_list):
        if l_list[l_cur] <= r_list[r_cur]:
            result.append(l_list[l_cur])
            l_cur += 1
        else:
            result.append(r_list[r_cur])
            r_cur += 1
    # 最后将剩下的元素增加到 result列表中
    result += l_list[l_cur:]
    result += r_list[r_cur:]
    return result

if __name__ == '__main__':
    li = [54, 26, 34, 17, 86, 42, 14,46,79,82,1]
    print(li)
    li_merge_list = merge_sort(li)
    print(li)
    print(li_merge_list)