目录
- 稳定的排序:冒泡排序、插入排序、归并排序
- 不稳定的排序:希尔排序、选择排序、堆排序、快速排序等
排序方法 | 稳定性 | 平均时间复杂度 | 最坏情况 | 最好情况 | 空间复杂度 |
---|---|---|---|---|---|
冒泡排序 | 稳定 | n^2 | n^2 | n | 1 |
选择排序 | 不稳定 | n^2 | n^2 | n^2 | 1 |
插入排序 | 稳定 | n^2 | n^2 | n | 1 |
快速排序 | 不稳定 | n·logn | n^2 | n·logn | n·logn |
希尔排序 | 不稳定 | n^1.3 | n^2 | n | 1 |
堆排序 | 不稳定 | n·logn | n·logn | n·logn | 1 |
归并排序 | 稳定 | n·logn | n·logn | n·logn | n |
计数排序 | 稳定 | n+k | n+k | n+k | n+k |
桶排序 | 稳定 | n+k | n^2 | n | n+k |
基数排序 | 稳定 | n*k | n*k | n*k | n+k |
- 交换排序:冒泡排序、快速排序
- 插入排序:简单插入排序、希尔排序
- 选择排序:简单选择排序、堆排序
- 归并排序:二路归并排序、多路归并排序
1. 快速排序
- 是一种分治思想(挖坑法/填坑法)。挑一个元素作为基准pivot,将所有比基准小的值摆在左侧,大的值摆在右侧,即分区partition
- 递归调用该方法完成所有排序。(左右分别找到大于或小于pivot的数,进行交换)
def partition(ls,l,r):
tmp = ls[l]
while l<r:
while l<r and ls[r] >= tmp:
r -= 1
ls[l] = ls[r]
while l<r and ls[l] <= tmp:
l += 1
ls[r] = ls[l]
ls[l] = tmp
return l
def quick_sort(ls,l,r):
if l>=r: return
pivot = partition(ls, l, r)
quick_sort(ls, l, pivot-1)
quick_sort(ls, pivot+1, r)
#—————————— E N D —————— E N D ——————————
# 简单写法
def partition2(ls,l,r):
i = l-1
for j in range(l,r):
if ls[j]<=ls[r]:
i += 1
ls[i],ls[j] = ls[j], ls[i]
ls[r], ls[i+1] = ls[i+1], ls[r]
return i
def quick_sort2(ls,l,r):
if l>=r: return
pivot = partition2(ls,l,r)
quick_sort(ls, l, pivot)
quick_sort(ls, pivot+1, r)
2. 冒泡排序 (稳定)
- 重复遍历列表,每一次遍历确定最后一位最大的数。
- 在遍历的过程中,依次比较相邻的元素。
def bubble_sort(ls):
for i in range(len(ls)-1):
for j in range(len(ls)-i-1):
if ls[j] > ls[j+1]:
ls[j], ls[j+1] = ls[j+1], ls[j]
return ls
3. 选择排序
- 在列表里找到最小的元素,依次往后填放
def selection_sort(ls):
for i in range(len(ls)-1):
min = i
for j in range(i+1,len(ls)):
if ls[j] < ls[min]:
min = j
ls[i], ls[min] = ls[min], ls[i]
return ls
4. 插入排序(稳定)
- 以第一个元素为基准(把第一个元素当作拍好的序列)
- 从第二个元素起,从当前元素向前扫描已排序的元素,不断交换,直到找到小于等于自己的元素,插到该元素后面。
def insertion_sort(ls):
for i in range(1,len(ls)):
now = i
for j in range(i-1,-1,-1):
if ls[j] > ls[now]:
ls[j], ls[now] = ls[now], ls[j]
now = j
else:
break
return ls