BUBBLE SORT Voraussetzungen der Schüler: Die Schüler besuchen bereits das zweite Jahr den Informatikunterricht und sollten den Umgang mit Feldern und Unterprogrammen mittlerweile beherrschen. Im ersten Jahrgang wurden bereits Aufgabenstellungen wie Minimum zweier Zahlen bestimmen oder drei Zahlen aufsteigend sortieren im Zusammenhang mit dem (geschachtelten) IF-THEN-ELSE behandelt. Einstieg: Einstiegsaufgabe: sortiere zuerst händisch drei vorgegebene Zahlen (z.b. 8, 4, 6 oder 7, 5, 3) in aufsteigender Reihenfolge und beschreibe, wie Du dabei vorgegangen bist. Die Schüler kommen hier meist auf einen dem Selection Sort ähnlichen Algorithmus. Manche erinnern sich auch noch an die Aufgabe aus dem Vorjahr und vergleichen aufeinanderfolgende Zahlen und vertauschen sie dann falls nötig. Zusatzfrage: Können wir die gefundenen Algorithmen auch auf Listen mit mehr als drei Elementen ausdehnen? Meine diesjährige Gruppe hat zuerst den Selection Sort für n zu sortierende Zahlen realisiert. Danach wurde die Struktur des Bubble Sorts anhand des folgenden Beispiels, welches händisch durchgespielt worden ist, nochmals veranschaulicht. Aufgabenstellung: Gegeben sei eine Liste von n Zahlen (bzw. Buchstaben), die aufsteigend (bzw. absteigend) mit Hilfe von Bubble Sort sortiert werden sollen. (Datenstruktur: ein Array der Länge n) Vorgangsweise des Bubble Sort Algorithmus für aufsteigende Sortierung: Das Array wird mehrmals durchlaufen, wobei ein fortgesetztes Vergleichen und Austauschen von Paaren nebeneinander liegender Elemente erfolgt. Man beginnt mit dem Vergleichen z.b. beim ersten Element des Arrays und schaut, ob dieses kleiner als das nächste Element ist. Ist dies nicht der Fall, werden die beiden Elemente vertauscht. Danach geht man zum zweiten Element weiter und vergleicht dieses mit dem dritten usw. Nach dem ersten Durchlauf steht das größte Element an der letzten Stelle. Nun muß noch das Feld im Index-Bereich [1..n-1] auf gleiche Weise sortiert werden. Bei jedem Durchlauf wandert das größte Element des betrachteten Array-Bereichs zum rechten Rand. (Bemerkung: Man könnte mit dem Vergleichen auch beim letzten Element beginnen. Falls das vorhergehende Element kleiner ist, ist kein Tausch notwendig, andernfalls schon. Auf diese Weise wandert das kleinste Element des betrachteten Bereiches an das linke Ende kleinstes Element an erster Stelle!) Evelin Kofler Bubble Sort Seite 1
Beispiel: Sortiere folgende Liste in aufsteigender Reihenfolge: 32, 51, 27, 85, 66, 23, 13, 57 Schritt 1: 32 51 27 85 66 23 13 57 32 51 27 51 51 85 66 85 23 85 13 85 57 85 Ergebnis 1: 32 27 51 66 23 13 57 85 Schritt 2: 32 27 51 66 23 13 57 85 27 32 32 51 51 66 23 66 13 66 57 66 Ergebnis 2: 27 32 51 23 13 57 66 85 Schritt 3: 27 32 51 23 13 57 66 85 Ergebnis 3: 27 32 23 13 51 57 66 85 Schritt 4: 27 32 23 13 51 57 66 85 Ergebnis 4: 27 23 13 32 51 57 66 85 Schritt 5: 27 23 13 32 51 57 66 85 Ergebnis 5: 23 13 27 32 51 57 66 85 Schritt 6: 23 13 27 32 51 57 66 85 Ergebnis 6: 13 23 27 32 51 57 66 85 Schritt 7: 13 23 27 32 51 57 66 85 Ergebnis 7: 13 23 27 32 51 57 66 85 Schritt 8: 13 23 27 32 51 57 66 85 kein Durchlauf mehr notwendig, da der verbleibende Array-Bereich nur mehr aus einem Element besteht und eine einelementige Liste ist sortiert! Die hier verwendete Beispielliste hat 8 Elemente. Die Liste ist nach 7 Schritten vollständig sortiert. Evelin Kofler Bubble Sort Seite 2
Bubble Sort benötigt bei n zu sortierenden Elementen n-1 Durchläufe und n 2 (n-1) + (n-2) +... + 2 + 1 = ( 1+ n 1) ( n 1) 1 2 = 2 n = O( n ) Vergleiche. aufwendiges und langsames Verfahren (Nachteil dieses Verfahrens: auch bei einem Feld, das bereits sortiert vorgegebenen ist, werden n-1 Durchläufe gemacht. Man könnte den Algorithmus verbessern, wenn man eine flag-variable mitführt, die sich die Anzahl der Vertauschungen eines Durchlaufes merkt. Wenn nämlich bei einem Durchlauf keine Vertauschungen mehr stattgefunden haben, dann ist das Feld bereits sortiert.) Es werden mit den Schülern auch die beiden Algorithmen (Selection Sort und Bubble Sort) in Bezug auf ihren Aufwand (Anzahl der Durchläufe, Vergleiche und Tauschoperationen) miteinander verglichen. Aufgabenstellung: (1) Schreibe ein iteratives Programm für Bubble Sort! (2) Schreibe ein rekursives Programm für Bubble Sort! (3) Ergänze Dein Programm um oben angeführten Verbesserungsvorschlag (flag)! Bei allen drei Aufgaben ist zuvor ein Blockbild zu erstellen! Evelin Kofler Bubble Sort Seite 3
Realisierung der iterativen Lösung Blockbild Grobentwurf: mit Hilfe des Zufallszahlengenerators anz ganze Zahlen aus dem Intervall [a,b] erzeugen die unsortierte Zahlenliste liste (zur Kontrolle) ausgeben die Zahlen (aufsteigend) sortieren die sortierte Zahlenliste ausgeben Benötigte Unterprogramme: generieren ( a, b, anz, liste) ausgeben ( anz, liste) bubble_sort ( anz, liste) generieren ( a, b, anz, liste) FOR i = 1 TO anz liste[i-1] generierte Zufallszahl aus [a,b] ausgeben ( anz, liste) FOR i = 1 TO anz A: liste[i-1] bubble_sort ( anz, liste) FOR ende = anz TO 2 BY -1 FOR i = 1 TO ende-1 IF liste[i-1] > liste[i] THEN dummy liste[i-1] liste[i-1] liste[i] liste[i] dummy Evelin Kofler Bubble Sort Seite 4
Programmcode in C (iterative Version) /* Autor : Evelin Kofler Datum : 3. Dezember 2001 Dateiname : bubble.cpp Funktion : aufsteigende Sortierung einer mit Hilfe des Zufallszahlengenerators generierten Zahlenliste nach dem Bubble Sort Algorithmus; iterative Lösung */ #include <stdio.h> #include <conio.h> #include <time.h> #include <stdlib.h> /*** globale Deklarationen ***/ const int maxanz = 25000; /* maximale Feldlaenge */ typedef int feld[maxanz]; /* Feld fuer ganze Zahlen */ /*** Prototypen ***/ void generieren(int a, int b, int anz, feld liste); /* <liste> enthaelt danach <anz> ganze Zahlen aus dem Wertebereich [a,b], die mit Hilfe eines Zufallszahlengenerators erzeugt werden */ void ausgeben(int anz, feld liste); /* gibt alle <anz> Elemente, die in <liste> gespeichert sind, aus */ void bubble_sort(int anz, feld liste); /* sortiert die <anz> Elemente, die in <liste> gespeichert sind, aufsteigend */ /*** Codierung der Unterprogramme ***/ void generieren(int a, int b, int anz, feld liste) int i; /* Zaehlvariable */ for(i=1;i<=anz;i++) liste[i-1]=random(b-a+1)+a; /* end generieren */ void ausgeben(int anz, feld liste) int i; /* Zaehlvariable */ for(i=1;i<=anz;i++) printf("%5d\t",liste[i-1]); /* end ausgeben */ Evelin Kofler Bubble Sort Seite 5
void bubble_sort(int anz, feld liste) int ende, /* Laenge des noch zu sortierenden Listenbereichs */ i; /* Zaehlvariable innerhalb eines Durchlaufs */ int dummy; /* Hilfsvariable fuer den Tausch zweier Zahlen */ for(ende = anz; ende >= 2; ende--) /* fuehre einen Durchlauf aus */ for(i = 1; i <= ende-1; i++) if (liste[i-1] > liste[i]) /* die beiden Elemente vertauschen */ dummy = liste[i-1]; liste[i-1] = liste[i]; liste[i] = dummy; /* end bubble_sort */ /******* Hauptprogramm ********/ void main() int ug, og, /* Grenzen des Wertebereichs, aus dem */ anz; /* anz Zufallszahlen generiert werden sollen */ feld zahlen; /* zu sortierende Zahlen */ /* Ausgabe einer Benutzerinfo und */ /* Einlesen der benoetigten Werte */ clrscr(); printf("\n\ndieses Programm sortiert Ihnen die von Ihnen angegebene"); printf("\nanzahl (max. %d) von Zufallszahlen aus dem von Ihnen ", maxanz); printf("\nvorgegebenen Wertebereich.\n\n\n"); printf("\ngewuenschte Anzahl von Zahlen : "); scanf("%d",&anz); while (anz<1 anz > maxanz) printf("\nunzulaessige Anzahl (max. %d) --> ",maxanz); printf("\ngewuenschte Anzahl von Zahlen : "); scanf("%d",&anz); printf("\nuntergrenze : "); scanf("%d",&ug); printf("\nobergrenze : "); scanf("%d",&og); while (og <= ug) printf("\n[%d,%d] ist ein unzulaessiges Intervall!!",ug,og); printf("\nuntergrenze : "); scanf("%d",&ug); printf("\nobergrenze : "); scanf("%d",&og); /* zu sortierende Zahlenliste erzeugen */ generieren(ug,og,anz,zahlen); /* unsortierte Liste ausgeben */ printf("\n\nunsortierte Liste :\n\n"); ausgeben(anz,zahlen); /* Zahlenliste sortieren */ bubble_sort(anz,zahlen); /* sortierte Liste ausgeben */ printf("\n\nsortierte Liste :\n\n"); ausgeben(anz,zahlen); /* end main */ Evelin Kofler Bubble Sort Seite 6
Programmcode in C (rekursive Version) /* Autor : Evelin Kofler Datum : 3. Dezember 2001 Dateiname : bubble_r.cpp Funktion : aufsteigende Sortierung einer mit Hilfe des Zufallszahlengenerators generierten Zahlenliste nach dem Bubble Sort Algorithmus; rekursive Version */ #include <stdio.h> #include <conio.h> #include <time.h> #include <stdlib.h> /*** globale Deklarationen ***/ const int maxanz = 25000; /* maximale Feldlaenge */ typedef int feld[maxanz]; /* Feld fuer ganze Zahlen */ /*** Prototypen ***/ void generieren(int a, int b, int anz, feld liste); /* <liste> enthaelt danach <anz> ganze Zahlen aus dem Wertebereich [a,b], die mit Hilfe eines Zufallszahlengenerators erzeugt werden */ void ausgeben(int anz, feld liste); /* gibt alle <anz> Elemente, die in <liste> gespeichert sind, aus */ void bubble_sort_rec(int anz, feld liste); /* sortiert die <anz> Elemente, die in <liste> gespeichert sind, aufsteigend */ /*** Codierung der Unterprogramme ***/ void generieren(int a, int b, int anz, feld liste) int i; /* Zaehlvariable */ for(i=1;i<=anz;i++) liste[i-1]=random(b-a+1)+a; /* end generieren */ void ausgeben(int anz, feld liste) int i; /* Zaehlvariable */ for(i=1;i<=anz;i++) printf("%5d\t",liste[i-1]); /* end ausgeben */ Evelin Kofler Bubble Sort Seite 7
void bubble_sort_rec(int anz, feld liste) int i, /* Zaehlvariable innerhalb eines Durchlaufs */ dummy; /* Hilfsvariable fuer den Tausch zweier Zahlen */ if (anz > 1) /* es liegt noch ein unsortierter Teil vor */ /* fuehre einen Durchlauf aus */ for(i = 1; i <= anz-1; i++) if (liste[i-1] > liste[i]) /* die beiden Elemente vertauschen */ dummy = liste[i-1]; liste[i-1] = liste[i]; liste[i] = dummy; /* sortiere das noch verbleibende Feld */ bubble_sort_rec(anz-1,liste); /* andernfalls ist nichts mehr zu sortieren */ /* end bubble_sort_rec */ /******* Hauptprogramm ********/ void main() int ug, og, /* Grenzen des Wertebereichs, aus dem */ anz; /* anz Zufallszahlen generiert werden sollen */ feld zahlen; /* zu sortierende Zahlen */ /* Ausgabe einer Benutzerinfo und */ /* Einlesen der benoetigten Werte */ clrscr(); printf("\n\ndieses Programm sortiert Ihnen die von Ihnen angegebene"); printf("\nanzahl (max. %d) von Zufallszahlen aus dem von Ihnen ", maxanz); printf("\nvorgegebenen Wertebereich.\n\n\n"); printf("\ngewuenschte Anzahl von Zahlen : "); scanf("%d",&anz); while (anz<1 anz > maxanz) printf("\nunzulaessige Anzahl (max. %d) --> ",maxanz); printf("\ngewuenschte Anzahl von Zahlen : "); scanf("%d",&anz); printf("\nuntergrenze : "); scanf("%d",&ug); printf("\nobergrenze : "); scanf("%d",&og); while (og <= ug) printf("\n[%d,%d] ist ein unzulaessiges Intervall!!",ug,og); printf("\nuntergrenze : "); scanf("%d",&ug); printf("\nobergrenze : "); scanf("%d",&og); /* zu sortierende Zahlenliste erzeugen */ generieren(ug,og,anz,zahlen); /* unsortierte Liste ausgeben */ printf("\n\nunsortierte Liste :\n\n"); ausgeben(anz,zahlen); /* Zahlenliste sortieren */ bubble_sort_rec(anz,zahlen); /* sortierte Liste ausgeben */ printf("\n\nsortierte Liste :\n\n"); ausgeben(anz,zahlen); /* end main */ Evelin Kofler Bubble Sort Seite 8
Auf Peter s Wunsch auch noch in einer zweiten Sprache (iterative Version) Aus Sentimentalität habe ich Modula-2 als zweite Sprache gewählt ;-) IntegerArray = ARRAY [1..100] OF INTEGER; PROCEDURE BubbleSort(anz : INTEGER; VAR liste : IntegerArray); VAR i, ende, dummy : INTEGER; BEGIN FOR ende := anz TO 2 BY 1 DO FOR i := 1 TO ende-1 DO IF liste[i] > liste[i+1] THEN dummy := liste[i]; liste[i] := liste[i+1]; liste[i+1] := dummy END (* IF *) END (* FOR i *) END (* FOR ende *) END BubbleSort; Evelin Kofler Bubble Sort Seite 9