列举至少2种排序算法（如快排），写出实现代码。

def insert_sort(alist):
    """插入排序"""
    n = len(alist)
    # 从第二个位置，即下标为1的元素开始向前插入
    for i in range(1, n):
        # 从第i个元素开始向前比较
        for j in range(i, 0, -1):
            if alist[j-1] > alist[j]:
                alist[j-1], alist[j] = alist[j], alist[j-1]
            else:
                break

def quick_sort(alist, first, last):
    """快速排序"""
    if first >= last:     # 递归头
        return

    mid_value = alist[first]
    low = first
    high = last

    while low < high:
        while low < high and alist[high] >= mid_value:
            high -= 1
        alist[low] = alist[high]
        while low < high and alist[low] < mid_value:
            low += 1
        alist[high] = alist[low]
    # 从循环退出时，low == high
    alist[low] = mid_value

    # 递归体
    # 对low左边的列表执行快速排序
    quick_sort(alist, first, low-1)
    # 对low右边的列表执行快速排序
    quick_sort(alist, low+1, last)

def merge_sort(alist):
    """归并排序"""
    n = len(alist)
    if n <= 1:
        return alist
    mid = n//2
    left_li = merge_sort(alist[:mid])
    right_li = merge_sort(alist[mid:])

    # 将两个有序的子序列合并成一个新的整体
    return merge(left_li, right_li)


def merge(left_li, right_li):
    """归并排序合并过程"""
    left_pointer, right_pointer = 0, 0
    result = []
    while left_pointer < len(left_li) and right_pointer < len(right_li):
        if left_li[left_pointer] <= right_li[right_pointer]:
            result.append(left_li[left_pointer])
            left_pointer += 1
        else:
            result.append(right_li[right_pointer])
            right_pointer += 1
    # 退出循环后，两个列表有一个元素已取完（切片操作允许越界，返回空列表）
    result += left_li[left_pointer:]
    result += right_li[right_pointer:]
    return result

def sift(data, low, high):
    """堆排序调整过程"""
    i = low  # 根节点
    j = 2 * i + 1  # 左子节点
    tmp = data[i]  # 缓存根节点数据
    while j <= high:  # 还未到达最后一个叶子结点
        if j < high and data[j] < data[j + 1]:
            # 如果存在右子节点，且右子节点更大
            j += 1  # 则此时目标转移到右子节点，接下来根节点与右子节点比较
        if data[j] > tmp:
            # 如果大的子节点数据大于根节点数据，则子节点上位
            data[i] = data[j]
            i = j
            j = 2 * i + 1
        else:
            # 否则不做调整
            break
    data[i] = tmp  # 根节点放置应该放置的数据


def heap_sort(data):
    """堆排序"""
    n = len(data)
    # 建堆
    for i in range(n // 2 - 1, -1, -1):  # 注：最后一个有子节点的根节点索引为n//2-1
        sift(data, i, n - 1)
    # 挨个出数
    for i in range(n - 1, -1, -1):  # 堆的规模不断减小
        data[0], data[i] = data[i], data[0]  # 将堆顶（此时堆中最大的数）的数用堆末的位置存储
        sift(data, 0, i - 1)  # 调整缩小的堆

def QuickSort(arr,firstIndex,lastIndex):
    if firstIndex<lastIndex:
        divIndex=Partition(arr,firstIndex,lastIndex)
 
        QuickSort(arr,firstIndex,divIndex)       
        QuickSort(arr,divIndex+1,lastIndex)
    else:
        return
 
 
def Partition(arr,firstIndex,lastIndex):
    i=firstIndex-1
    for j in range(firstIndex,lastIndex):
        if arr[j]<=arr[lastIndex]:
            i=i+1
            arr[i],arr[j]=arr[j],arr[i]
    arr[i+1],arr[lastIndex]=arr[lastIndex],arr[i+1]
    return i