【十大经典排序算法——python代码】

1. 冒泡排序（Bubble Sort）:

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        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

2. 选择排序（Selection Sort）：

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

3. 插入排序（Insertion Sort）：

def insertion_sort(arr):
    n = len(arr)
    for i in range(1, n):
        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

4. 希尔排序（Shell Sort）：

def shell_sort(arr):
    n = len(arr)
    gap = n // 2
    while gap > 0:
        for i in range(gap,n):
            temp = arr[i]
            j = i
            while j >= gap and arr[j-gap] >temp:
                arr[j] =arr[j-gap]
                j -=gap
            arr[j] = temp
        gap //= 2
    return arr

5. 归并排序（Merge Sort）：

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

6. 快速排序（Quick Sort）：

def quick_sort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)
        quick_sort(arr, low, pi-1)
        quick_sort(arr, pi+1, high)

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] <= pivot:
            i += 1 
            arr[i], arr[j] = arr[j], arr[i]
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return (i+1)

# 使用方法：quick_sort(arr,0,len(arr)-1)

7. 计数排序（Counting Sort）：

def counting_sort(arr):
    n = len(arr)
    output=[0]*n
    count=[0]*(max(arr)+1)
    for i in range(n):
        count[arr[i]]+=1
    for i in range(1,max(arr)+1):
        count[i]+=count[i-1]
    for i in range(n-1,-1,-1):
        output[count[arr[i]]-1]=arr[i]
        count[arr[i]]-=1
    for i in range(n):
        arr[i]=output[i]
    return arr

8. 桶排序（Bucket Sort）：

def bucket_sort(nums):
    max_num, min_num = max(nums), min(nums)
    bucket_range = (max_num - min_num) / len(nums)
    buckets = [[] for _ in range(len(nums) + 1)]
    for num in nums:
        buckets[int((num - min_num) // bucket_range)].append(num)
    res = []
    for bucket in buckets:
        if len(bucket) != 0:
            res += sorted(bucket)
    return res

9. 基数排序（Radix Sort）：

def radix_sort(arr):
    max_digit = len(str(max(arr)))
    
    for digit in range(max_digit):
        buckets = [[] for _ in range(10)]
        
        for num in arr:
            digit_num = get_digit(num, digit)
            buckets[digit_num].append(num)
        
        arr.clear()
        
        for bucket in buckets:
            arr.extend(bucket)

def get_digit(num, digit):
      return num // 10**digit % 10

10. 堆排序（Heap Sort）：

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

以上就是十大常见的排序算法及相应的 Python 代码实例。每种排序算法都有其适用场景，需要根据实际情况选择使用。

创作不易，还请点赞关注！