算法 | 排序 | 问题23

在计算机科学中，排序是一种重要的算法，它将一组元素按照特定的规则进行排列。问题23是一个排序问题，需要找到一组数据中第k小的元素。下面介绍常见的排序算法及其适用场景。

冒泡排序(Bubble Sort)

冒泡排序是一种简单直观的排序算法，它重复地遍历要排序的数组，比较相邻两个元素的大小，如果顺序不对就交换它们。该算法的时间复杂度为O(n^2)，空间复杂度为O(1)。

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]

arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("排序后的数组：")
for i in range(len(arr)):
    print("%d" % arr[i])

快速排序(Quick Sort)

快速排序是一种分治的排序算法。它首先选择一个基准元素，将数组分为左右两个子序列，比基准元素小的放在左边，大的放在右边，然后分别对左右两个子序列递归地进行快速排序。该算法的时间复杂度为O(nlogn)，空间复杂度为O(logn)。

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

def partition(arr, low, high):
    i = low - 1
    pivot = arr[high]
    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

arr = [64, 34, 25, 12, 22, 11, 90]
n = len(arr)
quick_sort(arr, 0, n-1)
print("排序后的数组：")
for i in range(n):
    print(arr[i]),

堆排序(Heap Sort)

堆排序是一种树形选择排序算法，它的主要思想是将待排序的数组构造成一个大(小)根堆，然后依次取出堆顶元素(最大或最小)，再把剩余元素调整为一个新的堆，循环执行该过程直到整个序列有序。该算法的时间复杂度为O(nlogn)，空间复杂度为O(1)。

def heap_sort(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[0], arr[i] = arr[i], arr[0]
        heapify(arr, i, 0)

def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1
    r = 2 * i + 2
    if l < n and arr[l] > arr[largest]:
        largest = l
    if r < n and arr[r] > arr[largest]:
        largest = r
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

arr = [64, 34, 25, 12, 22, 11, 90]
n = len(arr)
heap_sort(arr)
print("排序后的数组：")
for i in range(n):
    print(arr[i]),

以上三种排序算法是常见的排序算法，快速排序是效率较高的算法，但是在某些场景下堆排序也是一个很好的选择。

找到第k小的元素

若要找到第k小的元素，则可以使用快速排序算法，在递归过程中比较基准元素和k的大小关系，缩小排序范围。

def quick_sort_kth(arr, low, high, k):
    if low < high:
        pivot = partition(arr, low, high)
        if pivot == k:
            return arr[k]
        elif k < pivot:
            return quick_sort_kth(arr, low, pivot-1, k)
        else:
            return quick_sort_kth(arr, pivot+1, high, k)

arr = [64, 34, 25, 12, 22, 11, 90]
n = len(arr)
k = 3
result = quick_sort_kth(arr, 0, n-1, k-1)
print("第%d小的元素是：%d" % (k, result))

以上是使用快速排序算法找到第k小的元素。当然，也可以根据具体需求选择其他排序算法。