最低成本排序

最低成本排序是一種算法問題，通常指的是在給定的數據集中找到最小或最大的元素。這個問題有很多變體，但最基本的形式是找到一個序列中的最小值或最大值。

在計算機科學中，有很多算法可以用來解決這個問題，它們的複雜度從O(n)到O(n log n)不等，具體取決於數據集的大小和所需的精度。以下是一些常見的算法：

1. 線性掃描（O(n)）：這是最基本的算法，它遍歷整個數組並找到最小或最大的元素。

def find_min(arr):
    min_val = arr[0]
    for i in range(1, len(arr)):
        if arr[i] < min_val:
            min_val = arr[i]
    return min_val

2. 選擇排序（O(n^2)）：選擇排序首先找到最小元素，然後將其與第一個元素交換位置，接著找到第二個最小元素並交換，以此類推。

def selection_sort(arr):
    for i in range(len(arr)):
        min_index = i
        for j in range(i+1, len(arr)):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr

3. 快速排序（O(n log n)）：快速排序是一種分而治之的算法，它選擇一個樞軸（pivot），將數組分為兩個部分，然後遞歸地對這兩個部分進行排序。

def quick_sort(arr):
    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], arr[high] = arr[high], arr[i]
        return i + 1

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

    quick_sort_helper(arr, 0, len(arr) - 1)
    return arr

4. 堆排序（O(n log n)）：堆排序使用二叉堆數據結構來存儲數組，並從中找到最小或最大的元素。

def heap_sort(arr):
    n = len(arr)
    build_max_heap(arr, n)
    for i in range(n-1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        max_heapify(arr, i, 0)
    return arr

def build_max_heap(arr, n):
    for i in range(n//2, -1, -1):
        max_heapify(arr, n, i)

def max_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]
        max_heapify(arr, n, largest)

選擇哪種算法取決於數據集的大小、所需的精度和性能要求。例如，如果數據集很小，那麼線性掃描可能是最簡單和最快的選擇。如果數據集很大，那麼快速排序或堆排序可能是更好的選擇，因為它們的複雜度更低。