排序算法-基础

冒泡排序

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)

总结：速度：快排<归并<堆

 缺点： 快排：不稳定，极端情况效率低

             归并：需要额外内存开销

              堆排序：相对较慢