So sortieren Sie in Python

Python-Sortiermethoden umfassen Blasensortierung, Auswahlsortierung, Einfügungssortierung, Schnellsortierung, Zusammenführungssortierung, Heap-Sortierung, Radix-Sortierung usw. Detaillierte Einführung: 1. Blasensortierung, Sortieren durch Vergleich benachbarter Elemente und Austausch ihrer Positionen. 2. Auswahlsortierung, Sortieren durch Suchen des kleinsten Elements in der Liste und Platzieren am Ende des sortierten Teils. 3. Einfügungssortierung, Sortieren nach Einfügen jedes Elements an der entsprechenden Position des sortierten Teils; 4. Schnelle Sortierung mit der Divide-and-Conquer-Methode, um die Liste in kleinere Unterlisten usw. zu unterteilen.

Das Betriebssystem dieses Tutorials: Windows 10-System, Python-Version 3.11.4, Dell G3-Computer.

Python ist eine leistungsstarke Programmiersprache, die mehrere Sortiermethoden zum Sortieren von Daten bereitstellt. In diesem Artikel stellen wir mindestens 7 verschiedene Sortiermethoden vor und liefern detaillierte Codebeispiele.

1. Blasensortierung:

Die Blasensortierung ist ein einfacher Sortieralgorithmus, der durch den Vergleich benachbarter Elemente und den Austausch ihrer Positionen sortiert. Die Liste wird wiederholt durchlaufen, bis keine Swaps mehr stattfinden.

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. Auswahlsortierung:

Auswahlsortierung ist ein einfacher Sortieralgorithmus, der sortiert, indem er das kleinste Element in der Liste findet und es am Ende des sortierten Teils platziert.

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. Einfügungssortierung:

Einfügungssortierung ist ein einfacher Sortieralgorithmus, der sortiert, indem jedes Element an der entsprechenden Position des sortierten Teils eingefügt wird.

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:

Quick Sort ist ein effizienter Sortieralgorithmus, der die Divide-and-Conquer-Methode verwendet, um eine Liste in kleinere Unterlisten aufzuteilen 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. Merge Sort:

Merge Sort ist ein effizienter Sortieralgorithmus, der die Divide-and-Conquer-Methode verwendet, um die Liste in kleinere Unterlisten aufzuteilen, die Unterlisten dann rekursiv zu sortieren und sie schließlich zu einer geordneten Liste zu kombinieren.

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-Sortierung:

Heap-Sortierung ist ein effizienter Sortieralgorithmus, der eine binäre Heap-Datenstruktur zum Sortieren verwendet.

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-Sortierung:

Radix-Sortierung ist ein nicht vergleichender Sortieralgorithmus, der Elemente nach der Anzahl der Ziffern sortiert.

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

Hier finden Sie detaillierte Codebeispiele für 7 verschiedene Sortiermethoden. Je nach Datensatz und Leistungsanforderungen kann die Auswahl eines geeigneten Sortieralgorithmus die Effizienz und Leistung des Codes verbessern

Das obige ist der detaillierte Inhalt vonSo sortieren Sie in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!