# 快速排序
# 时间复杂度: O(nlogn)
# 最坏情况: o(n2)
# li = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
# 递归最大深度问题
# 设置递归最大深度问题、、
# import sys
# sys.setrecursionlimit(1000000)
'''
取一个元素P,使元素P归位
列表被分成了两半,左边都比P小,右边都比P大
递归
'''
print('---------------')
def partition(data, left, right):
tmp = data[left]
while left < right:
while left < right and data[right] >= tmp: # 从右边找比tmp小的数
right -= 1 # 往左走一步
data[left] = data[right] # 把右边的值写到左边的空位上
while left < right and data[left] <= tmp: # 从左边找比tmp大的数
left += 1 # 往右走一步
data[right] = data[left] # 把左边的值写到右边的空位上
data[left] = tmp # 把tmp归位
return left
def quick_sort(data, left, right):
if left < right:
mid = partition(data, left, right)
quick_sort(data, left, mid - 1)
quick_sort(data, mid + 1, right)
return data
li = [3, 2, 1, 5, 4, 9, 7, 8, 6]
print(quick_sort(li, 0, len(li) - 1))
print('---------------------')
# 堆排序
# 树结构 :n个节点组成的集合
# 二叉树
# 节点的度:几个分叉就有几个度
# 树的度:最大节点的度
# 根节点、叶节点、树的深度(高度)
# 孩子节点/父节点
# 子树
# 时间复杂度为O(nlogn)
# 快排比堆排更快
# 内置模块:headq
'''
二叉树:
度不超过2的树
满二叉树:
完全二叉树:从满二叉树中拿走一些叶节点,必须从左到右排列
二叉树的存储方式:
链式存储方式
顺序存储方式(列表存储)父亲找孩子,孩子找父亲 i——》2i+1(左孩子) i-->2i+2(右孩子)
堆: 特殊的完全二叉树
大根堆:比孩子节点大
小根堆:比孩子节点小
堆的向下调整性:节点的左右子树都是堆,但是自身不是堆
当根节点的左右子树都是堆时,可以通过一次向下的调整来将其变换成一个堆
堆排序的过程:
挨个出数,选根节点作为棋子,选最后一个
构造堆:
从最后一个叶节点对应的根节点开始,农村包围城市,从小的开始
堆排序的过程:
1、建立堆(构造堆)
2、得到堆顶元素,为最大元素
3、去掉堆顶,将堆最后一个元素放到堆顶,此时可通过一次调整重新使堆有序
4、堆顶元素为第二大元素
5、重复步骤3、直至堆变空
'''
# 向下调整的实现
def sift(data, low, high):
'''
:param data: 列表
:param low: 堆顶根节点的位置
:param high: 堆最后一个元素的位置
:return:
'''
i = low # i最开始指向根节点
j = 2 * i + 1 # 左孩子
tmp = data[low] # 把堆顶存起来
while j <= high:
if j + 1 <= high and data[j + 1] > data[j]: # 如果右孩子有并且比较大
j = j + 1 # j指向右孩子
if data[j] > tmp:
data[i] = data[j]
i = j # 往下看一层
j = 2 * i + 1
else: # tmp更大,把tmp放在i的位置上
data[i] = tmp # 将tmp放在某一级领导位置上
break
else:
data[i] = tmp # 把tmp放在叶子节点上
return data
def heap_sort(data):
n = len(data)
for i in range((n - 2) // 2, -1, -1):
# i代表建堆的时候调整的部分的根的下标
sift(data, i, n - 1)
# 建堆完成了
# 挨个出数
for i in range(n - 1, -1, -1):
# i 指向当前堆的最后一个元素
data[0], data[i] = data[i], data[0]
sift(data, 0, i - 1)
return data
data = [2, 1, 4, 3, 4, 7, 8, 5, 6, 9]
print(data)
data = heap_sort(data)
print(data)
print('--------------------')
import heapq # q->queue 优先队列,先进先出
import random
li = list(range(100))
random.shuffle(li)
print(li)
heapq.heapify(li) # 建堆
n = len(li)
for i in range(n):
print(heapq.heappop(li), end=' ')
'''
堆排序 --- topk问题
设计算法得到前k大的数
解决思路:
先排序在切片 o(nlogn)
排序lowB三人组 O(kn)
堆排序思路 o(nlogk)
取列表前k个元素建立一个小根堆。堆顶就是目前第k大的数
依次向后遍历列表,对于列表中的元素,如果小于堆顶,则忽略该元素;如果大于堆顶,则将堆顶更换为该元素,并且对堆进行一次调整
遍历列表所有元素后,倒叙弹出堆顶
topk问题:
'''
# 向下调整的实现
# 比较排序
print('\n<-------------------------->')
def sift(data, low, high):
'''
:param data: 列表
:param low: 堆顶根节点的位置
:param high: 堆最后一个元素的位置
:return:
'''
i = low # i最开始指向根节点
j = 2 * i + 1 # 左孩子
tmp = data[low] # 把堆顶存起来
while j <= high:
if j + 1 <= high and data[j + 1] < data[j]: # 如果右孩子有并且比较大
j = j + 1 # j指向右孩子
if data[j] < tmp:
data[i] = data[j]
i = j # 往下看一层
j = 2 * i + 1
else: # tmp更大,把tmp放在i的位置上
# data[i] = tmp # 将tmp放在某一级领导位置上
break
# else:
data[i] = tmp # 把tmp放在叶子节点上
return data
def heap_sort(data):
n = len(data)
for i in range((n - 2) // 2, -1, -1):
# i代表建堆的时候调整的部分的根的下标
sift(data, i, n - 1)
# 建堆完成了
# 挨个出数
for i in range(n - 1, -1, -1):
# i 指向当前堆的最后一个元素
data[0], data[i] = data[i], data[0]
sift(data, 0, i - 1)
return data
def topk(data, k):
heap = data[0:k]
for i in range((k - 2) // 2, -1, -1):
sift(heap, i, k - 1)
# 1、建堆
for i in range(k, len(data) - 1):
if data[i] > heap[0]:
heap[0] = data[i]
sift(heap, 0, k - 1)
# 2、遍历
for i in range(k - 1, -1, -1):
heap[0], heap[i] = heap[i], heap[0]
sift(heap, 0, i - 1)
# 3、出数
return heap
import random
data = list(range(1000))
random.shuffle(data)
print(topk(data, 10))
# 归并排序
# 时间复杂度为 o(nlogn)
# 空间复杂度为 o(n)
'''
假设咱现在的列表 分成两段有序,如何将其和成为一个有序列表
一次归并
'''
print('==========================')
def merge(data, low, mid, high):
i = low
j = mid + 1
li = []
while i <= mid and j <= high:
if data[i] <= data[j]:
li.append(data[i])
i += 1
else:
li.append(data[j])
j += 1
# while 执行完,肯定有一个没数了
while i <= mid:
li.append(data[i])
i += 1
while j <= high:
li.append(data[j])
j += 1
data[low:high + 1] = li
'''
无序的归并排序
用递归
'''
def mergesort(data, low, high):
if low < high: # 至少有两个元素,归并
mid = (high + low) // 2
mergesort(data, low, mid) # 左边排好序
mergesort(data, mid + 1, high) # 右边排好序
merge(data, low, mid, high) # 合并
# print(data[low:high+1])
# data = [2, 4, 5, 7, 1, 3, 6, 8]
# merge(data, 0, 3, 7)
# print(data)
print('\n=============================>>')
data = list(range(1000))
random.shuffle(data)
print(data)
mergesort(data, 0, len(data) - 1)
print(data)
'''
NB三人组小结
time:
快排<归并排序<堆排序
缺点:
快排:极端情况下排序效率低
归并:需要额外的内存开销
堆排序:在快的排序算法中相对较慢
稳定:
冒泡 、 直接插入、归并
不稳定:
直接选择、快排、堆排序
挨着的换位置的是稳定的
跳着换位置的是不稳定的
递归: 需要用到系统栈
'''
NB三人组及其时间复杂度
最新推荐文章于 2024-09-09 23:28:21 发布