三大中级算法

• 难度 ★★
• 算法复杂度O(nlogn)
• 一般情况下排序时间： 快速排序< 归并排序 < 堆排序

• 快速排序

  ： 缺点极端情况下效率低

• 堆排序

  ： 缺点在快的排序算法中相对慢

• 归并排序

  ： 缺点要有额外内存空间

快速排序 ★★

quick Sort

算法复杂度: O(nlogn) <n乘logn>

思路

每趟取第一个元素，让列表被该元素分为两部分，左边的比他小，右边比他大, 重复用每次得来的第一个元素递归

问题1：

递归py有最大深度问题999次！（虽然可以设置）

问题2：

最坏的情况，如果列表本身是一个倒序列表，那么效率相对较低

（解决方案：随机快排，一开始就随机取一个数放在最左边开始排）

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)

def partition(li, left, right):
"""
将下标为0的元素为参照物，左边的放比他小的，右边放比他大的
"""
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  # 或者返回right都行

li_test = [3, 2, 7, 1, 6, 9, 8, 4]
quick_sort(li_test, 0, len(li_test)-1)
print(li_test)

堆排序 ★★

算法复杂度: O(nlogn) <n乘logn>

前提

二叉树的知识储备！！

效率：

快排的时间复杂度优于堆排

def sift(li, low, high):
"""
调整堆
:param li: 列表
:param low: 堆的根节点
:param high: 堆的最后一个元素位置
:return:
"""
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:  # tmp更大，把tmp放到i位置上
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

li_test = [3, 2, 7, 1, 6, 9, 8, 4]
heap_sort(li_test)
print(li_test)

堆排序py 模块

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问题 【常用】

问题：比如热搜网，有n个数，取前k打的数（排序好的）

思路

1. 取列表前k个元素建立小根堆，堆顶是目前第k大的数
2. 依次向后面遍历原列表，对于列表中的元素，如果小于堆顶，则忽略该元素，反之换为该元素，并进行一次调整
3. 遍历素有元素后，倒序弹出堆顶

import random

def sift(li, low, high):
"""
调整为小根堆
:param li: 列表
:param low: 堆的根节点
:param high: 堆的最后一个元素位置
:return:
"""
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:  # tmp更大，把tmp放到i位置上
li[i] = tmp  # 把tmp放到某一级领导位置上
break
else:
li[i] = tmp  # 把tmp放到叶子节点上

def top_key(li, k):
heap = li[0:k]
for i in range((k-2)//2, -1, -1):
sift(heap, i, k-1)
# 1.建堆
for i in range(k, len(li)-1):
if li[i] > heap[0]:
heap[0] = li[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

li = list(range(1000))
random.shuffle(li)

print(top_key(li, 10))  # 测试 前10数

归并排序 ★★

算法复杂度: O(nlogn) <n乘logn>

空间复杂度: O(n)

思路

假设两个列表已有序，那么将他们合并在一起，将列表越分越小，直到分为一个元素

def merge(li, low, mid, high):
"""
:param li: 列表
:param low: 左列表第一个元素
:param mid: 左列表最后一个元素，那么右列表第一个就是mid+1
:param high: 右列表最后一个元素
:return:
"""
i = low  # 第一段第一个元素
j = mid + 1  # 第二段的第一个元素
tmp_list = []
while i <= mid and j <= high:  # 必须左右有数
if li[i] < li[j]:
tmp_list.append(li[i])
# 移动后箭头必须移动一位，因为已经把小的值提出到临时list中
i += 1
else:
tmp_list.append(li[j])
j += 1
# while 执行完，说明有一段执行完了，剩下的接到tmp中即可
# 分别判断一下那个还有数
while i <= mid:
tmp_list.append(li[i])
i += 1
while j <= high:
tmp_list.append(li[j])
j += 1
li[low:high+1] = tmp_list  # 写回去

def merge_sort(li, low, high):
if low < high:  # 至少有2个元素，递归
mid = (low + high) // 2  # 整除2
merge_sort(li, low, mid)
merge_sort(li, mid+1, high)
merge(li, low, mid, high)

li_test = [3, 2, 7, 1, 6, 9, 8, 4]
merge_sort(li_test, 0, len(li_test)-1)
print(li_test)