Bubblesort
Zuletzt aktualisiert
Bubblesort durchläuft die Liste wiederholt, vergleicht jedes Paar benachbarter Elemente und vertauscht sie, wenn sie in der falschen Reihenfolge sind. Nach jedem vollständigen Durchlauf ist der größte verbleibende Wert an seine korrekte Position am Ende "aufgestiegen", sodass jeder Durchlauf ein Element weniger betrachtet. Drücke oben auf Abspielen, um die Vergleiche und Vertauschungen zu beobachten, oder gehe sie einzeln durch.
Es ist einer der am leichtesten verständlichen Sortieralgorithmen, was ihn zu einem großartigen ersten Algorithmus macht - aber seine Laufzeit von O(n²) macht ihn für große Eingaben unpraktikabel.
Zeit- und Speicherkomplexität
| Fall | Komplexität | Hinweise |
|---|---|---|
| Bester Fall | O(n) | Bereits sortiert, mit einer Früh-Abbruch-Prüfung |
| Durchschnittsfall | O(n²) | Zufällige Reihenfolge |
| Schlechtester Fall | O(n²) | Umgekehrt sortiert |
| Speicher | O(1) | In-place, nur eine temporäre Variable |
| Stabil | Ja | Gleiche Elemente behalten ihre relative Reihenfolge |
Schritt für Schritt
| Schritt | Was passiert |
|---|---|
| 1 | Beginne am Anfang des Arrays. |
| 2 | Vergleiche das aktuelle Element mit dem nächsten. |
| 3 | Wenn sie in falscher Reihenfolge sind, vertausche sie. |
| 4 | Rücke eine Position nach rechts und wiederhole bis zum Ende (ein Durchlauf). |
| 5 | Wiederhole die Durchläufe; jeder Durchlauf fixiert ein weiteres Element am Ende. |
| 6 | Stoppe, wenn ein vollständiger Durchlauf keine Vertauschungen macht. |
Durchgerechnetes Beispiel
Sortieren von [5, 2, 4, 1]:
| Durchlauf | Array | Aktion |
|---|---|---|
| 1 | [2, 4, 1, 5] | Vertausche 5,2, dann 5,4, dann 5,1; die 5 steigt ans Ende auf. |
| 2 | [2, 1, 4, 5] | 2,4 in Ordnung; vertausche 4,1; 4,5 in Ordnung; die 4 ist nun platziert. |
| 3 | [1, 2, 4, 5] | Vertausche 2,1; der Rest ist bereits in Ordnung; die 2 ist platziert. |
| 4 | [1, 2, 4, 5] | Ein vollständiger Durchlauf macht keine Vertauschungen, also ist das Array sortiert und der Algorithmus stoppt. |
Wann man Bubblesort verwendet
| Verwende es, wenn | Vermeide es, wenn |
|---|---|
| Du lehrst oder lernst, wie vergleichsbasierte Sortierverfahren funktionieren | Du große Eingaben sortierst, bei denen O(n²) viel zu langsam ist |
Die Eingabe winzig oder fast sortiert ist (mit Früh-Abbruch nähert es sich O(n)) | Du das schnellste Allzweck-Sortierverfahren brauchst - verwende Quicksort oder Mergesort |
| Du ein stabiles, In-place-Sortierverfahren mit fast keinem Code willst | Die Daten in zufälliger Reihenfolge vorliegen und die Leistung wichtig ist |
| Du in einem Durchlauf erkennst, ob eine kurze Liste bereits sortiert ist | Viele Schreibvorgänge teuer sind (z. B. Flash-Speicher); Selectionsort macht weniger Vertauschungen |
Bubble Sort-Code
Eine saubere, lauffähige Bubble Sort-Implementierung in Python, JavaScript, Java, C++, C. Wähle eine Sprache, kopiere den Code oder öffne ihn vorgeladen im Coddy-Playground.
Bubble Sort-Code in Python
1def bubble_sort(a):2 n = len(a)3 for i in range(n - 1):4 swapped = False5 for j in range(n - 1 - i):6 if a[j] > a[j + 1]:7 a[j], a[j + 1] = a[j + 1], a[j]8 swapped = True9 if not swapped:10 break # no swaps means the list is already sorted11 return a12
13
14nums = [5, 1, 4, 2, 8]15print("Before:", nums)16bubble_sort(nums)17print("After: ", nums)Bubble Sort-Code in JavaScript
1function bubbleSort(a) {2 for (let end = a.length - 1; end > 0; end--) {3 let swapped = false;4 for (let j = 0; j < end; j++) {5 if (a[j] > a[j + 1]) {6 [a[j], a[j + 1]] = [a[j + 1], a[j]];7 swapped = true;8 }9 }10 if (!swapped) break; // Already sorted: stop early11 }12 return a;13}14
15const data = [5, 2, 9, 1, 7, 3];16console.log("Before:", data);17console.log("Sorted:", bubbleSort([...data]));Bubble Sort-Code in Java
1import java.util.Arrays;2
3public class Main {4 static void bubbleSort(int[] arr) {5 for (int i = arr.length - 1; i > 0; i--) {6 boolean swapped = false;7 for (int j = 0; j < i; j++) {8 if (arr[j] > arr[j + 1]) {9 int tmp = arr[j];10 arr[j] = arr[j + 1];11 arr[j + 1] = tmp;12 swapped = true;13 }14 }15 if (!swapped) break; // already sorted16 }17 }18
19 public static void main(String[] args) {20 int[] arr = {5, 1, 4, 2, 8, 3};21 System.out.println("Before: " + Arrays.toString(arr));22 bubbleSort(arr);23 System.out.println("After: " + Arrays.toString(arr));24 }25}Bubble Sort-Code in C++
1#include <iostream>2#include <utility>3#include <vector>4
5void printVec(const std::vector<int>& a) {6 for (int x : a) std::cout << x << " ";7 std::cout << "\n";8}9
10void bubbleSort(std::vector<int>& a) {11 for (size_t pass = 0; pass + 1 < a.size(); ++pass) {12 bool swapped = false;13 // Each pass bubbles the largest remaining value to the end14 for (size_t j = 0; j + 1 < a.size() - pass; ++j) {15 if (a[j] > a[j + 1]) {16 std::swap(a[j], a[j + 1]);17 swapped = true;18 }19 }20 if (!swapped) break; // already sorted21 }22}23
24int main() {25 std::vector<int> data = {5, 1, 4, 2, 8, 3};26 std::cout << "Before: ";27 printVec(data);28 bubbleSort(data);29 std::cout << "After: ";30 printVec(data);31 return 0;32}Bubble Sort-Code in C
1#include <stdbool.h>2#include <stdio.h>3
4void printArr(const int a[], int n) {5 for (int i = 0; i < n; i++) printf("%d ", a[i]);6 printf("\n");7}8
9void bubbleSort(int a[], int n) {10 for (int pass = 0; pass < n - 1; pass++) {11 bool swapped = false;12 // Each pass bubbles the largest remaining value to the end13 for (int j = 0; j < n - 1 - pass; j++) {14 if (a[j] > a[j + 1]) {15 int tmp = a[j];16 a[j] = a[j + 1];17 a[j + 1] = tmp;18 swapped = true;19 }20 }21 if (!swapped) break; // already sorted22 }23}24
25int main(void) {26 int data[] = {5, 1, 4, 2, 8, 3};27 int n = sizeof(data) / sizeof(data[0]);28 printf("Before: ");29 printArr(data, n);30 bubbleSort(data, n);31 printf("After: ");32 printArr(data, n);33 return 0;34}Bubblesort-FAQ
Wie hoch ist die Zeitkomplexität von Bubblesort?
O(n²). Mit einer Früh-Abbruch-Optimierung kann es bei einem bereits sortierten Array O(n) erreichen. Es verwendet O(1) zusätzlichen Speicher.Ist Bubblesort stabil?
Warum heißt es Bubblesort?
Was ist der Unterschied zwischen Bubblesort und Insertionsort?
O(n²) und sind stabil und in-place, bewegen die Daten aber unterschiedlich: Bubblesort vertauscht wiederholt benachbarte fehlgeordnete Paare, während Insertionsort jedes Element nimmt und es an seine korrekte Stelle im sortierten Präfix schiebt. Insertionsort macht meist weniger Schreibvorgänge und ist in der Praxis schneller, besonders bei fast sortierten Daten.Wann sollte ich Bubblesort statt Quicksort verwenden?
O(n log n)-Zeit von Quicksort zermalmt Bubblesorts O(n²) bei allem außer winzigen Eingaben. Bubblesort lohnt sich nur, wenn die Liste sehr klein oder fast sortiert ist, oder wenn du das einfachstmögliche stabile Sortierverfahren zum Lehren möchtest.Ändert die Früh-Abbruch-Optimierung den schlechtesten Fall von Bubblesort?
O(n) erreichen, aber ein umgekehrt sortiertes Array benötigt weiterhin jeden Vergleich, sodass der schlechteste Fall O(n²) bleibt. Die Optimierung hilft nur im besten und in fast sortierten Fällen.