一、冒泡排序

冒泡排序是最简单的排序方法之一，其核心思想是将相邻的两个元素进行比较，如果顺序不对就交换它们的位置，重复这个过程直到所有的元素都按照从小到大的顺序排列。

def bubble_sort(arr):  
    n = len(arr)  
    for i in range(n-1):  
        for j in range(0, n-i-1):  
            if arr[j] > arr[j+1] :  
                arr[j], arr[j+1] = arr[j+1], arr[j]  
    return arr

其中，arr为待排序的数组，函数返回值为排序后的数组。

二、插入排序

插入排序的思想是将待排序的数组一次插入到已经排好序的数组中，从而得到一个新的、更大的有序数组。

def insertion_sort(arr):  
    for i in range(1, len(arr)):  
        key = arr[i]  
        j = i-1
        while j >=0 and key < arr[j] :  
                arr[j+1] = arr[j]  
                j -= 1  
        arr[j+1] = key  
    return arr

其中，arr为待排序的数组，函数返回值为排序后的数组。

三、快速排序

快速排序是一种分治排序算法，它的原理是选择一个基准值，将小于这个基准值的数放到它的左边，大于它的数放到右边，然后在左右两个子数组中重复这个过程，直到整个数组有序。因为快速排序的平均时间复杂度为 O(nlogn)，所以它是最常用的排序算法之一。

def quick_sort(arr):  
    if len(arr) <= 1:  
        return arr  
    else:  
        # 选择中间的元素作为基准点  
        pivot = arr[len(arr) // 2]  
        left = [x for x in arr if x  pivot]  
        return quick_sort(left) + middle + quick_sort(right)

其中，arr为待排序的数组，函数返回值为排序后的数组。

四、堆排序

堆排序是一种树形选择排序算法，它的原理是将待排序的数组看成一棵完全二叉树，将它转换成一个简单的堆，然后将根节点与最后一个节点交换，使得最大的元素在数组的末尾，重复这个过程直到整个数组有序。

def heapify(arr, n, i):  
    largest = i   
    l = 2 * i + 1    
    r = 2 * i + 2   
 
    if l < n and arr[i] < arr[l]:  
        largest = l  
 
    if r < n and arr[largest] < arr[r]:  
        largest = r   
    if largest != i:  
        arr[i],arr[largest] = arr[largest],arr[i]  
 
        heapify(arr, n, largest)  
 
def heap_sort(arr):  
    n = len(arr)  
    for i in range(n, -1, -1):  
        heapify(arr, n, i)  
    for i in range(n-1, 0, -1):  
        arr[i], arr[0] = arr[0], arr[i]  
        heapify(arr, i, 0)
    return arr

其中，arr为待排序的数组，函数返回值为排序后的数组。

五、归并排序

归并排序是一种分治排序算法，它的原理是将待排序的数组分成两个子数组，然后递归地对它们进行排序，最后将两个有序的子数组合并成一个有序的数组。

def merge_sort(arr):  
    if len(arr) > 1:  
        mid = len(arr)//2  
        L = arr[:mid]   
        R = arr[mid:]  
        merge_sort(L)   
        merge_sort(R)  
        i = j = k = 0    
        while i < len(L) and j < len(R):  
            if L[i] < R[j]:  
                arr[k] = L[i]  
                i += 1  
            else:  
                arr[k] = R[j]  
                j += 1  
            k += 1    
        while i < len(L):  
            arr[k] = L[i]  
            i += 1  
            k += 1    
        while j < len(R):  
            arr[k] = R[j]  
            j += 1  
            k += 1    
    return arr

其中，arr为待排序的数组，函数返回值为排序后的数组。