冒泡排序
def bubble_sort(li):
for i in range(len(li)-1): # 第i趟
for j in range(len(li)-i-1): # 一趟比j次
if li[j] > li[j+1]:
li[j], li[j+1] = li[j+1], li[j]
时间复杂度O(N2)
改进:如果一趟没有任何顺序改变,就认为无序区已经排好了
def bubble_sort(li):
for i in range(len(li)-1):
exchange = False
for j in range(len(li)-i-1):
if li[j] > li[j+1]:
li[j], li[j+1] = li[j+1], li[j]
exchange = True
if not exchange:
return
选择排序
def select_sort_simple(li):
res = []
for i in range(len(li)):
min_val = min(li)
res.append(min_val)
li.remove(min_val)
return res
缺点:占内存,时间复杂度O(N2)
def select_sort(li):
for i in range(len(li)-1): #i是第几趟
min_loc = i
for j in range(i + 1, len(li)):
if li[j] < li[min_loc]:
min_loc = j
if min_loc != i:
li[i], li[min_loc] = li[min_loc], li[i]
记录无序区最小数的位置,便于交换
插入排序
def insert_sort(li):
for i in range(1,len(li)): #i 表示摸到牌的下标
tmp = li[i]
j = i - 1 #手里牌的下标
while j >= 0 and li[j] > tmp:
li[j+1] = li[j]
j -= 1
li[j+1] = tmp
时间复杂度O(N2)
前三总结:原地排序,复杂度O(N2)
快速排序
def partition(li, left, right):
tmp = li[left]
while left < right:
while left < right and li[right] >= tmp: #从右面找比tmp小的数放左边
right -= 1 #往左走一步
li[left] = li[right] # 把右边的值放到左边的空位上
while left < right and li[left] <= tmp:
left += 1
li[right] = li[left]
li[left] = tmp # 归位 tmp
return left
def quick_sort(li, left, right):
if left < right: #至少两个元素
mid = partition(li, left, right)
quick_sort(li, left, mid-1)
quick_sort(li, mid+1, right)
时间复杂度:O(NlogN)
堆排序
堆是一个特别的完全二叉树
二叉树的存储方式:
链式存储方式
顺序存储方式:用列表存
大根堆,小根堆
向下调整性质:
假设左右节点子树都是堆,但自身不是堆
可以通过一次向下的调整来将其变换成一个堆
堆排序过程:
1、建立一个堆 2、得到堆顶元素为最大元素 3、去掉堆顶 4、拿最后一个元素上去,向下调整,堆顶元素为第二大元素 5、重复步骤3,直到堆空
1如何构建堆:
看最后一个分叶子节点,开始农村包围城市,从下往上不断有序,最后成一个堆
# 调整函数
def sift(li, low, high):
"""
li:列表
low:堆的根节点位置
high:堆的最后一个元素的位置
"""
i = low # i最开始指向根节点
j = 2*i +1 # 左孩子
tmp = li[low] # 把堆顶存起来
while j <= high : # 只要j位置有数
if j+1 <= high and li[j+1] > li[j]: #如果右孩子存在,并且比较大
j = j+1 #j指向右孩子
if li[j] > tmp:
li[i] = li[j]
i = j #往下走一层
j = 2*i +1
else:
li[i] = tmp # 把tmp放到某一级领导的位置
break
else:
li[i] = tmp # 把 tmp放到 村民位置
def heap_sort(li):
n = len(li)
for i in range((n-2)//2, -1, -1):
# i 代表建堆时调整的部分的根的下标
sift(li, i, n-1)
# 建堆完成
for i in range(n-1 , -1, -1):
# i 指向当前最后一个元素
li[0], li[i] = li[i], li[0]
sift(li, 0, i-1) # i-1是新的high
时间复杂度:O(NlogN)
堆排序内置模块
import heapq
heapq.heapify(li) # 建小根堆
heapq.heappop(li) # 弹出最小元素
topk问题:
思路: 1.排序后切片
2.前三种排序
3.堆排序思路
取列表前k元素建一个小根堆,堆顶是目前第k大的数
依次向后遍历列表,对于列表中的元素,如果小于堆顶,忽略,如果大于堆顶,则将堆顶更换为该元素,并对堆进行一次调整
遍历所有列表后,倒序弹出堆顶
# 调整函数 改为小根堆
def sift(li, low, high):
"""
li:列表
low:堆的根节点位置
high:堆的最后一个元素的位置
"""
i = low # i最开始指向根节点
j = 2*i +1 # 左孩子
tmp = li[low] # 把堆顶存起来
while j <= high : # 只要j位置有数
if j+1 <= high and li[j+1] < li[j]: #如果右孩子存在,并且比较大
j = j+1 #j指向右孩子
if li[j] < tmp:
li[i] = li[j]
i = j #往下走一层
j = 2*i +1
else:
li[i] = tmp # 把tmp放到某一级领导的位置
break
else:
li[i] = tmp # 把 tmp放到 村民位置
def topk(li,k):
heap = li[0:k]
for i in range((k-2)//2, -1, -1):
sift(heap, i, k-1)
#建堆
for i in range(k, len(li)-1):
if li[i] > heap[0]:
heap[0] = li[i]
sift(heap, 0, k-1)
#遍历
for i in range(k-1 , -1, -1):
# i 指向当前最后一个元素
heap[0], heap[i] = heap[i], heap[0]
sift(heap, 0, i-1) # i-1是新的high
return heap
#出数
归并排序
归并:假设现在的列表分两段有序,如何将其合成一个有序列表
# 归并
def merge(li, low, mid, high):
i = low
j = mid +1
tmp = []
while i <= mid and j <= high: # 只要左右两边都有数
if li[i] < li[j]:
tmp.append(li[i])
i += 1
else:
tmp.append(li[j])
j += 1
while i <= mid:
tmp.append(li[i])
i += 1
while j <= high:
tmp.append(li[j])
j += 1
li[low:high+1] = tmp
def merge_sort(li, low, high):
if low < high : # 至少有两个元素
mid = (low + high) // 2
merge_sort(li, low, mid)
merge_sort(li, mid+1, high)
merge(li, low, mid, high)
sort()是基于归并排序的
时间复杂度:O(NlogN),空间复杂度O(N)
总结:速度:快排<归并<堆
缺点: 快排:不稳定,极端情况效率低
归并:需要额外内存开销
堆排序:相对较慢