Was sind die Sortieralgorithmen in Python?

Zu den häufig verwendeten Sortieralgorithmen in Python gehören Blasensortierung, Einfügungssortierung, Auswahlsortierung, Schnellsortierung, Zusammenführungssortierung und Heap-Sortierung. Im Folgenden werden die Prinzipien dieser Sortieralgorithmen vorgestellt und entsprechende Codebeispiele gegeben.

1. Bubble Sort:
   Bubble Sort ist ein einfacher und intuitiver Sortieralgorithmus. Es durchläuft wiederholt die zu sortierende Liste, vergleicht die Größe zweier benachbarter Elemente und verschiebt das größere Element nach hinten. Während jeder Iteration „blubbert“ das größte Element an das Ende der Liste.

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

2. Einfügesortierung:
   Die Grundidee der Einfügesortierung besteht darin, die zu sortierenden Elemente einzeln an der richtigen Position in die sortierte Liste einzufügen. Die Einfügesortierung beginnt beim zweiten Element, vergleicht jedes Element mit der vorherigen sortierten Liste und fügt es an der entsprechenden Position ein.

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

3. Auswahlsortierung:
   Auswahlsortierung durchläuft jedes Mal die Liste, findet das kleinste Element und tauscht es mit der aktuellen Position aus. Wiederholen Sie diesen Vorgang so lange, bis die gesamte Liste sortiert ist.

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

4. Quick Sort:
   Quick Sort ist ein effizienter Sortieralgorithmus. Es nutzt die Idee von ​​​​Divide and Conquer, um eine Liste in zwei Unterlisten zu teilen und die Unterlisten dann rekursiv zu sortieren.

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. Sortierung zusammenführen:
   Sortierung zusammenführen teilt die Liste in zwei Unterlisten, sortiert jede Unterliste und führt dann die sortierten Unterlisten zusammen.

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    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-Sortierung:
   Heap-Sortierung ist ein Baumauswahl-Sortieralgorithmus, der die Eigenschaften binärer Heaps zum Sortieren verwendet. Heaps können in Max-Heaps und Min-Heaps unterteilt werden. Der Wurzelknoten des Max-Heaps ist das größte Element und der Wurzelknoten des Min-Heaps ist das kleinste Element.

def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2
    if left < n and arr[i] < arr[left]:
        largest = left
    if right < n and arr[largest] < arr[right]:
        largest = right
    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

Die oben genannten sind einige häufig verwendete Sortieralgorithmen in Python und entsprechende Codebeispiele werden bereitgestellt. Verschiedene Sortieralgorithmen eignen sich für unterschiedliche Situationen und Datengrößen. Die Auswahl eines geeigneten Sortieralgorithmus entsprechend der tatsächlichen Situation kann die Betriebseffizienz des Programms verbessern.

Das obige ist der detaillierte Inhalt vonWas sind die Sortieralgorithmen in Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!