python怎麼排序

python排序方法有冒泡排序、選擇排序、插入排序、快速排序、歸併排序、堆排序、基數排序等等。詳細介紹：1、冒泡排序，透過比較相鄰的元素並交換它們的位置來進行排序；2、選擇排序，透過找到清單中最小的元素，並將其放在已排序部分的末尾來進行排序；3、插入排序，透過將每個元素插入到已排序部分的適當位置來進行排序；4、快速排序，用分治法將列表分割為較小的子列表等等。

本教學作業系統：Windows10系統、Python3.11.4版本、Dell G3電腦。

Python是一種功能強大的程式語言，提供了多種排序方法來對資料進行排序。在本文中，我們將介紹至少7種不同的排序方法，並提供詳細的程式碼範例。

1. 冒泡排序（Bubble Sort）:

冒泡排序是一種簡單的排序演算法，它透過比較相鄰的元素並交換它們的位置來進行排序。它重複地遍歷列表，直到沒有任何交換發生為止。

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

2. 選擇排序（Selection Sort）:

選擇排序是一種簡單的排序演算法，它透過找到清單中最小的元素，並將其放在已排序部分的末尾來進行排序。

def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if arr[j] < arr[min_idx]:
                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 arr[j] > key:
            arr[j+1] = arr[j]
            j -= 1
        arr[j+1] = key
    return arr

4. 快速排序（Quick Sort）:

快速排序是一種高效的排序演算法，它使用分治法將列表分割為較小的子列表，然後遞歸地對子清單進行排序。

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr)//2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

5. 歸併排序（Merge Sort）:

歸併排序是一種高效的排序演算法，它使用分治法將列表分割為較小的子列表，然後遞歸地對子列表進行排序，最後將它們合併為一個有序列表。

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]
    left = merge_sort(left)
    right = merge_sort(right)
    return merge(left, right)
def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

6. 堆排序（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//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

7. 基數排序（Radix Sort）:

基數排序是一種非比較的排序演算法，它根據元素的位數進行排序。

def counting_sort(arr, exp):
    n = len(arr)
    output = [0] * n
    count = [0] * 10
    for i in range(n):
        index = arr[i] // exp
        count[index % 10] += 1
    for i in range(1, 10):
        count[i] += count[i-1]
    i = n - 1
    while i >= 0:
        index = arr[i] // exp
        output[count[index % 10] - 1] = arr[i]
        count[index % 10] -= 1
        i -= 1
    for i in range(n):
        arr[i] = output[i]
def radix_sort(arr):
    max_val = max(arr)
    exp = 1
    while max_val // exp > 0:
        counting_sort(arr, exp)
        exp *= 10
    return arr

這是7種不同的排序方法的詳細程式碼範例。根據不同的資料集和效能要求，選擇適合的排序演算法可以提高程式碼的效率和效能 

以上是python怎麼排序的詳細內容。更多資訊請關注PHP中文網其他相關文章！