【力扣Leetcode】排序专题（Python刷题）：插入、选择、冒泡、快速、归并、堆排

leetcode刷题，python实现排序，持续更新……（先写个大纲，后续刷题后更新）

基本排序模板：

复杂度O(n^2)：插入排序，选择排序，冒泡排序

复杂度O(nlogn)：快速排序，归并排序，堆排序

其它：希尔排序，计数排序，桶排序，基数排序（这四个用到再更吧）

题目：242，912，56，179，215，75，969

剑指 Offer Ⅱ：075，077，

面试题：10.01，10.09，16.16

剑指 Offer：51

目录

复杂度O(n^2)：插入排序，选择排序，冒泡排序

复杂度O(nlogn)：快速排序，归并排序，堆排序

---

复杂度O(n^2)：插入排序，选择排序，冒泡排序

选择排序：从无序区选择比i更小的值与i交换。→每趟选择出当前最小值放在前面。

class Solution:
    def select_sort(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)-1):       # 无序区第一个值与其余值比较，更小的放在无序区第一位
            for j in range(i+1,len(nums)): # 一共需要n-1趟，每次在列表最前面排出最小值
                if nums[j]<nums[i]:
                    nums[i],nums[j]=nums[j],nums[i]
        return nums

冒泡排序：相邻两值比较，更大的值放在后面的位置，对于每个i，选取当前最大的值放在无序区的最后一个位置。一共比较n-1趟，每趟比较n-1-i次。

class Solution:
    def buble_sort(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)-1):       # 每轮选取无序区最大的值放在最后面
            for j in range(len(nums)-1-i): # 相邻两值比较，更大的放在后面
                if nums[j]>nxums[j+1]:
                    nums[j],nums[j+1]=nums[j+1],nums[j]
        return nums

冒泡排序改进：当剩余数据已经是有序的时候（整体都是有序也有可能），即在过程中没有发生过比较大小后的交换，此时就无需在进行后面重复比较，直接返回即可。

class Solution:
    def buble_sort(self, nums: List[int]) -> List[int]:
        exchange=False
        for i in range(len(nums)-1):       # 每轮选取无序区最大的值放在最后面
            for j in range(len(nums)-1-i): # 相邻两值比较，更大的放在后面
                if nums[j]>nxums[j+1]:
                    nums[j],nums[j+1]=nums[j+1],nums[j]
                    exchange=True
            if exchange=False:
                return nums
        return nums

插入排序（打扑克抓牌，放入合适位置）：每次将无序区第一个值与有序区作比较，选择合适的插入位置。从有序区最后一个值开始比较，满足条件则进行交换，不断逼近最合适的插入位置。因为在有序区域插入了一个值，所以有序区比待插入值大的值索引都后移了一位。

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        for i in range(1,len(nums)):
            tmp=nums[i]                 # 待插入位置的值，即无序区第一位的值
            j=i-1                       # 指针指向待插入位置左边的值，即有序区最后一位
            while tmp<nums[j] and j>-1: # 待插入的值与指针位置的值作比较，更小则插入
                nums[j+1]=nums[j]
                nums[j]=tmp
                j-=1                    # 指针左移，将待插入值与更小的值作比较，不断逼近最合适的插入位置
        return nums     

复杂度O(nlogn)：快速排序，归并排序，堆排序

快速排序

import random

def partition(left, right, nums):
    tmp = nums[left]
    while left < right:
        while left < right and nums[right] >= tmp:
            right -= 1
        nums[left] = nums[right]
        while left < right and nums[left] <= tmp:
            left += 1
        nums[right] = nums[left]    
    nums[left] = tmp    
    return left

def quick_sort(left,right, nums):
    "左右两侧，各自有序"
    if left < right:
        mid = partition(left, right, nums)
        quick_sort(left, mid-1, nums)
        quick_sort(mid + 1, right, nums)
    return nums

if __name__ == "__main__":
    nums = [i for i in range(10)]
    random.shuffle(nums)
    print(nums)
    print(quick_sort(0, len(nums)-1, nums))

堆排序

大根堆

import random

def sift(nums, low, high):
    """向下调整"""
    i = low  # 当前根节点
    j = 2 * i + 1   # 根节点对应的左孩子
    tmp = nums[low]
    while j <= high:
        if j+1 <= high and nums[j+1] > nums[j]: # 如果右孩子存在且大于左孩子，那么指针指向右孩子
            j = j+1  
        if nums[j] > tmp: # 如果大孩子比根节点大，则右孩子赋给根节点，指针再向下看一层
            nums[i] = nums[j]
            i = j
            j = 2 * i + 1
        else: # 大孩子<根节点，跳出
            nums[i] = tmp #tmp放在某一级领导位置上
            break   
    else:         # 把tmp放在叶子节点上
        nums[i] = tmp        

def heap_sort(nums):
    """建堆，农村包围城市，从堆的下面逐步调用sift"""
    n = len(nums)
    for i in range((n-1-1)//2, -1, -1): # 从最后一个根节点开始调整
        sift(nums, i, n-1)
    for i in range(n-1, -1, -1):  # 从小到大输出
        nums[0], nums[i] = nums[i], nums[0]
        sift(nums, 0, i-1)
    return nums

if __name__ == "__main__":
    nums = [_ for _ in range(20)]
    random.shuffle(nums)
    print(nums)
    print(heap_sort(nums))

归并排序

import random

def merge(nums, left, mid, right):
    i = left
    j = mid + 1
    tmp = []
    while i <= mid and j <= right :
        if nums[i] < nums[j]:
            tmp.append(nums[i])
            i +=1
        else:
            tmp.append(nums[j])
            j +=1
    while i <= mid:
        tmp.append(nums[i])
        i += 1
    while j <= right:
        tmp.append(nums[j])
        j += 1
    nums[left : right + 1] = tmp

def merge_sort(nums, left, right):
    if left < right:
        mid = (left + right)//2
        merge_sort(nums, left, mid)
        merge_sort(nums, mid+1, right)
        merge(nums, left, mid, right)
    return nums

if __name__ == "__main__":
    nums = [i for i in range(16)]
    random.shuffle(nums)
    print(nums)
    print(merge_sort(nums, 0, len(nums)-1))

做实验去了，明天继续……