cursor自动生成代码使用

1、cursor地址

2、cursor

输入cmd+k，在输入框里面键入想要实现的功能

3、实例

排序算法

# 冒泡排序
def bubbleSort(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

# 选择排序
def selectionSort(arr):
    n = len(arr)
    for i in range(n):
        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

# 插入排序
def insertionSort(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

# 快速排序
def quickSort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]
        left = []
        right = []
        for i in arr[1:]:
            if i < pivot:
                left.append(i)
            else:
                right.append(i)
        return quickSort(left) + [pivot] + quickSort(right)

# 归并排序
def mergeSort(arr):
    if len(arr) > 1:
        mid = len(arr)//2
        L = arr[:mid]
        R = arr[mid:]
        mergeSort(L)
        mergeSort(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

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 heapSort(arr):
    n = len(arr)
    for i in range(n // 2 - 1, -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
    
def shellSort(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
    
def countingSort(arr):
    max_val = max(arr)
    m = max_val + 1
    count = [0] * m                
    for a in arr:
        count[a] += 1             
    i = 0
    for a in range(m):            
        for c in range(count[a]): 
            arr[i] = a
            i += 1
    return arr
    
# def bucketSort(arr):
#     bucket = []
#     for i in range(len(arr)):
#         bucket.append([])
#     for j in arr:
#         index_b = int(10 * j)
#         bucket[index_b].append(j)
#     for i in range(len(arr)):
#         bucket[i] = insertionSort(bucket[i])
#     k = 0
#     for i in range(len(arr)):
#         for j in range(len(bucket[i])):
#             arr[k] = bucket[i][j]
#             k += 1
#     return arr

arr=[1,3,5,7,9,2,4,6,8,0]
# print(bubbleSort(arr))
# print(selectionSort(arr))
# print(insertionSort(arr))
# print(quickSort(arr))
# print(mergeSort(arr))
# print(heapSort(arr))
# print(shellSort(arr))
# print(countingSort(arr))
print(bucketSort(arr))

除了桶排序，其他排序实现真实有效

排序算法总结见链接：