冒泡排序
- 它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来
- 算法运作:
1. 比较相邻的元素。如果第一个比第二个大(升序),就交换他们两个
2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤,除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
def bubble_sort(li):
"""冒泡排序"""
for j in range(len(li)-1, 0, -1): # 每次遍历需要比较的次数,逐渐减小
for i in range(0, j):
# 比较相邻两数,大的放右边
if li[i] > li[i+1]:
li[i], li[i+1] = li[i+1], li[i]
- 时间复杂度:
- 最优时间复杂度:O(n) (表示遍历一次发现没有任何可以交换的元素,排序结束。)
- 最坏时间复杂度:O(n^2)
- 稳定性:稳定
选择排序
- 首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
def select_sort(li):
n = len(li)
for j in range(n-1): # 进行n-1次排序
min_index = j # 最小序列
for i in range(j+1, n):
if li[i] < li[min_index ]:
min_index = i # 选出最小序列
if min_index != j:
li[j], li[min_index ] = li[min_index ], li[j]
- 时间复杂度:
- 最优时间复杂度:O(n^2)
- 最坏时间复杂度:O(n^2)
- 稳定性:不稳定
插入排序
- 通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
def insert_sort(li):
"""插入排序"""
# 从第二个元素下标开始比较
for i in range(1, len(li)):
for j in range(i, 0, -1): # 假设一个有序数列
# 从第j 个元素开始向前比较,遇到小的则交换。
if li[j] < li[j - 1]:
li[j], li[j - 1] = li[j - 1], li[j]
else:
brea
- 时间复杂度:
- 最优时间复杂度:O(n) (升序排列,序列已经处于升序状态)
- 最坏时间复杂度:O(n^2)
- 稳定性:稳定
希尔排序
- 也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。
- 将数组列在一个表中并对列分别进行插入排序,重复这过程,不过每次用更长的列(步长更长了,列数更少了)来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法,算法本身还是使用数组进行排序。
def shell_sort(li):
n = len(li)
# 确定初始步长:
gap = n // 2
while gap > 0:
# 按照步长,进行插入排序
for i in range(gap, n):
j = i
while j >= gap and li[j] < li[j-gap]:
li[j], li[j-gap] = li[j-gap], li[j]
j -= gap
gap //= 2
- 时间复杂度:
- 最优时间复杂度:根据步长序列的不同而不同
- 最坏时间复杂度:O(n^2)
- 稳定性:不稳定
快速排序
-
又称划分交换排序(partition-exchange sort),通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列
-
步骤:
- 从数列中挑出一个元素,称为"基准"(pivot),
- 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
- 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
def quick_sort(li, start, end):
"""
快速排序
:param li: 需要排序的列表
:param start: 起始下标
:param end: 结束下标
:return:
"""
# 退出递归条件
if start >= end:
return
# 取开始数为基准数
mid = li[start]
# 序列从左向右游标
life = start
# 序列从右向左游标
right = end
while left < right:
# 先从右游标开始移动
while left < right and li[right] > mid:
right -= 1
# 右游标的数交给坐游标
li[life] = li[right]
# 从左往右移动
while left < right and li[left] <= mid:
left += 1
li[right] = li[left]
# 退出循环后,low与high重合,此时所指位置为基准元素的正确位置
# 将基准元素放到该位置
li[left] = mid
# 递归
quick_sort(li, start, left - 1)
quick_sort(li, left + 1, end)
归并排序
- 先递归分解数组,再合并数组。
def merge_sort(li):
"""归并排序"""
n = len(li)
# 递归的退出条件
if n == 1:
return li
mid = n // 2
left_li = li[:mid]
right_li = li[mid:]
# 对左半部分排序,按照归并思想
left_sorted_li = merge_sort(left_li)
# 对右半部分进行排序
right_sorted_li = merge_sort(right_li)
# 设置2个游标
left, right = 0, 0
left_n = len(left_sorted_li)
right_n = len(right_sorted_li)
# 进行合并
merged_li = []
while left < left_n or right < right_n:
if left_sorted_li[left] <= right_sorted_li[right]:
merged_li.append(left_sorted_li[left])
left += 1
else:
merged_li.append(right_sorted_li[right])
right += 1
# 退出循环时表示有一个列表的所有元素都已经添加到新的列表中
# 处理剩下的列表
merged_li.extend(left_sorted_li[left:])
merged_li.extend(right_sorted_li[right:])
return merged_li
- 时间复杂度:
- 最优时间复杂度:O(nlogn)
- 最坏时间复杂度:O(nlogn)
- 稳定性:稳定