python版冒泡、选择、插入、希尔、归并、快速排序总结

部分内容转自https://www.cnblogs.com/pungchur/p/12080326.html，总结的非常好。会加入希尔、归并、和快排。

冒泡排序

介绍

依次比较相邻两元素，若前一元素大于后一元素则交换之，直至最后一个元素即为最大；

然后重新从首元素开始重复同样的操作，直至倒数第二个元素即为次大元素；

依次类推。如同水中的气泡，依次将最大或最小元素气泡浮出水面

实现

# 冒泡排序
def bubble_sort(li):
    # 建立一个标识符
    flag = False
    for i in range(len(li)-1):
        for j in range(len(li)-i-1):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
                flag = True
        # 如果没进行交换，则本身有序，直接break
        if not flag:
            break
    return li

算法分析

• 平均时间复杂度：O(n2)，标准的内外两层循环
• 最好时间复杂度：O(n)，如果有序，那么第一趟就ok了
• 最坏时间复杂度：O(n2)
• 空间复杂度：O(1)
• 稳定性：稳定的

选择排序

介绍

首先初始化最小元素索引值为首元素，依次遍历待排序数列，若遇到小于该最小索引位置处的元素则刷新最小索引为该较小元素

的位置，直至遇到尾元素，结束一次遍历，并将最小索引处元素与首元素交换；

然后，初始化最小索引值为第二个待排序数列元素位置，同样的操作，可得到数列第二个元素即为次小元素；以此类推

实现

# 选择排序 O(n^2)
# 从第一个元素开始选择最小的元素放在第一位，然后再选择第二个元素
def select_sort(li):
    for i in range(len(li)-1):
        # 第i趟 无序区范围i到最后
        min_pos = i # 无序区最小值位置
        for j in range(i+1, len(li)):
            if li[j] < li[min_pos]:
                min_pos = j
        li[i], li[min_pos] = li[min_pos], li[i]

算法分析

• 平均时间复杂度：O(n2)，嵌套双循环
• 最好时间复杂度：O(n2)，每次要找最大最小肯定是要遍历一遍的
• 最坏时间复杂度：O(n2)
• 空间复杂度：O(1)
• 稳定性：稳定的

插入排序

介绍

将列表分为有序区和无序区两个部分，最初有序区只有一个元素，即第一个元素。

然后每次从无序区选择一个元素，插入到有序区中，直到无序区为空。

如下图，橙色为有序区，浅蓝色为无序区。

实现

def insert_sort(li):
	for i in range(1,len(li)):
		while i > 0 :
			#如果当前的数比维护的序列的最后一个小，那么调换位置
			if li[i] < li[i-1]:
				li[i],li[i-1] = li[i-1],li[i]
				#调换位置后还要看当前数排在维护序列的哪一个位置
				i -= 1
			else:
				break
	return li
			

算法分析

• 平均时间复杂度：O(n2)
• 最好时间复杂度：O(n)，如果有序，那么每个元素都已经在在它的待排子序列的合适位置，不用找合适位置
• 最坏时间复杂度：O(n2)
• 空间复杂度：O(1)
• 稳定性：稳定的

快排

实现

def quick_sort(li, start, end):
    # 分治 一分为二
    # start=end ,证明要处理的数据只有一个
    # start>end ,证明右边没有数据
    if start >= end:
        return
    # 定义两个游标，分别指向0和末尾位置
    left = start
    right = end
    # 把0位置的数据，认为是中间值
    mid = li[left]
    while left < right:
        # 让右边游标往左移动，目的是找到小于mid的值，放到left游标位置
        while left < right and li[right] >= mid:
            right -= 1
        li[left] = li[right]
        # 让左边游标往右移动，目的是找到大于mid的值，放到right游标位置
        while left < right and li[left] < mid:
            left += 1
        li[right] = li[left]
    # while结束后，把mid放到中间位置，left=right
    li[left] = mid
    # 递归处理左边的数据
    quick_sort(li, start, left-1)
    # 递归处理右边的数据
    quick_sort(li, left+1, end)
 
if __name__ == '__main__':
    l = [6,5,4,3,2,1]
    # l = 3 [2,1,5,6,5,4]
    # [2, 1, 5, 6, 5, 4]
    quick_sort(l,0,len(l)-1)
    print(l)
    # 稳定性：不稳定
    # 最优时间复杂度：O(nlogn)
    # 最坏时间复杂度：O(n^2)

归并排序

递归详细说明

def MergeSort(arrayList):
	arrayLen = len(arrayList)
	#判断输入参数的正确性
	if arrayLen <= 1:
		return arrayList
	middleIndex = (arrayLen >> 1)
	#递归左半部分
	sortedLeft = MergeSort(arrayList[:middleIndex])
	#递归右半部分
	sortedRight = MergeSort(arrayList[middleIndex:])
	return MergeCore(sortedLeft,sortedRight)#排序

def MergeCore(leftList,rightList):
	leftIndex = 0
	rightIndex = 0
	
	leftLen = len(leftList)
	rightLen = len(rightList)
	retList = []
	
	#循环比较
	while leftIndex < leftLen and rightIndex < rightLen:
		if leftList[leftIndex] < rightList[rightIndex]:
			retList.append(leftList[leftIndex])
			leftIndex += 1
		else:
			retList.append(rightList[rightIndex])
			rightIndex += 1
	# 将剩余的数组放入到返回值的数组
	if leftIndex < leftLen:
		while leftIndex < leftLen:#需要注意 这里一定要用while
			retList.append(leftList[leftIndex])
			leftIndex += 1
	if rightIndex < rightLen:
		while rightIndex < rightLen:
			retList.append(rightList[rightIndex])
			rightIndex += 1
	return retList