Ubungspaket 15 ¨
Einfaches Sortieren, Suchen und Finden
Ubungsziele: ¨
1. Erarbeiten der Funktionsweise eines einfachen Sortieralgorithmus 2. Implementierung von Bubble Sorts
3. Suchen und Finden in sortierten und unsortierten Arrays Skript:
Kapitel: 27 und 33 Semester:
Wintersemester 2021/22 Betreuer:
Thomas, Tim und Ralf Synopsis:
Sortieren, Suchen und Finden geh¨ oren zu den Standardaufgaben in der Informatik, die auch in vielen Anwendungen f¨ ur uns Elektrotechniker relevant sind. Beim Sortieren von Daten gehen wir im Rahmen dieses Ubungspaketes davon aus, dass bereits bei der Programmerstellung fest ¨ steht, wie groß das Datenarray sein soll. F¨ ur das Sortieren verwenden wir den einfachsten Algorithmus, der auch unter dem Namen Bubble Sort bekannt ist. Um ein Element zu suchen und nach M¨ oglichkeit auch zu finden, verwenden wir ebenfalls einen sehr einfachen Algorithmus:
das lineare Durchsuchen eines Arrays. Diese Themen werden wir wieder in ¨ Ubungspaket 21 aufgreifen.
Da wir die
” Zutaten“ f¨ ur diese Algorithmen schon hatten, werden wir in
den ersten drei Abschnitten (Stoffwiederholung, Quiz und Fehlersuche)
keinen neuen Stoff ein¨ uben, sondern bereits Gelerntes nochmals kurz
wiederholen. Wer hier auf Schwierigkeiten st¨ oßt, sollte sich zun¨ achst
noch einmal die entsprechenden ¨ Ubungspakete anschauen.
Teil I: Stoffwiederholung
Aufgabe 1: Definition eindimensionaler Felder
Zun¨achst ein paar allgemeine Fragen bzw. Teilaufgaben zu Arrays. Zeige anhand zweier Beispiele, wie man eindimensionale Felder definiert.
1.
2.
Welche Indizes haben die Elemente eines Arrays mit 12 Elementen?
Nehmen wir mal an, wir wollen im weiteren Verlauf unseres Programms auf die einzelnen Elemente eines zuvor definierten Feldes zugreifen. Hierf¨ur m¨ussen wir vor allem die Gr¨oße des Feldes wissen. Wie f¨uhren wir g¨unstigerweise die Definition durch, damit das Programm m¨oglichst ¨anderungsfreundlich ist? Zeige dies anhand eines Beispiels einer Definition nebst einer Initialisierung:
Aufgabe 2: Ein-/Ausgabe von Arrays
Aufgabe 3: Arbeiten mit Array-Elementen
Nehmen wir wieder an, wir haben ein Array feld vom Typ int, das 20 Elemente haben soll. Wie sieht die Definition aus?
Beantworte die folgenden Fragen anhand eines frei gew¨ahlten Beispiels.
Wie vergleicht man zwei benachbarte Elemente?
Wie vertauscht man sie?
Nehmen wir an, wir f¨uhren obige Vergleiche etc. mit folgender Schleife durch:
1 for ( i = 0; . . . ; i = i + 1 ) // die S c h l e i f e
2 if ( . . . ) // der V e r g l e i c h
3 { . . . } // die A n w e i s u n g e n
Wie muss obige Schleifenbedingung richtig lauten?
Begr¨unde kurz deine Antwort
Zum Abschluss formulieren wir die Frage noch einmal anders: Nehmen wir an, wir ha- ben ein Array der Gr¨oße SIZE. Nehmen wir ferner an, wir vergleichen nacheinander alle benachbarten Elemente i und i+1.
Wie viele Vergleiche werden durchgef¨uhrt?
Teil II: Quiz
Aufgabe 1: Schleifen und Arrays
Nehmen wir an, wir haben ein Array und vergleichen benachbarte Elemente miteinander, wie wir es gerade eben in Aufgabe 3 gemacht haben. Nehmen wir ferner an, dass wir das Array aufsteigend sortieren wollen.
”Aufsteigend“ heißt hier, dass sich an der Stelle 0 das kleinste Element und an der StelleSIZE - 1das gr¨oßte Element befindet. Daf¨ur verwenden wir folgende Definitionen und Anweisungen (rudiment¨ar, ohne richtiges Programm):
1 # d e f i n e S I Z E 4 2 int i , h , a [ S I Z E ];
3
4 for ( i = 0; i < S I Z E - 1; i = i + 1 ) 5 if ( a [ i ] > a [ i + 1 ] )
6 {
7 h = a [ i ]; a [ i ] = a [ i + 1 ]; a [ i + 1 ] = h ;
8 }
F¨ur die folgende Handsimulation nehmen wir an, dass das Array wie folgend belegt ist:
Elemente a[ 0 ] a[ 1 ] a[ 2 ] a[ 3 ]
Werte 4711 27 42 2
F¨uhre in der folgenden Handsimulation schrittweise alle Vergleiche und ggf. die resultie- renden Tausch-Operationen durch.
a[ 0 ] a[ 1 ] a[ 2 ] a[ 3 ] i Vergleich Indizes Vergleich Werte initial: 4711 27 42 2 0 . . . . . . . . . . . . . . . . . . . . . . . .
Teil III: Fehlersuche
Aufgabe 1: Finden und Z¨ ahlen von Anstiegen
Das folgende Programm besitzt ein Array, in dem einige Werte vorliegen. Das Programm soll feststellen, wann ein Wert ai+1 gr¨oßer als ai ist. Ferner soll das Programm ausgeben, wie viele dieser positiven Vergleiche es gefunden hat.
1 # i n c l u d e < s t d i o . h >
2
3 int m a i n ( int argc , c h a r ** a r g v )
4 {
5 int i , cnt ;
6 int a [] = { 1 2 4 0 -2 33 4 7 1 1 815 };
7 # d e f i n e S I Z E ( s i z e o f ( a ) / s i z e o f ( a [ 0 ] ) ) 8
9 for ( i = 0 , i < SIZE , i = i + 1 )
10 if ( a [ i ] < a [ i + 1 ] )
11 cnt = cnt + 1;
12 p r i n t f ( " %5 d - - > %5 d \ n " , a [ i ] , a [ i + 1] ) ; 13
14 p r i n t f ( " % d mal s t e i g e n d \ n " , cnt ) ; 15 r e t u r n 0;
16 }
Teil IV: Anwendungen
Aufgabe 1: Sortieren mittels Bubble Sort
Ziel dieser Aufgabe ist die Entwicklung des wohl einfachsten Sortieralgorithmus, der auch unter dem NamenBubble Sort bekannt ist. Wie bisher in diesem ¨Ubungspaket gehen wir davon aus, dass sich die zu sortierenden Daten in einem Array befinden und dass wir die Daten aufsteigend sortieren wollen; also das kleinste Element an die Stelle mit dem Index0 und das gr¨oßte Element an die Stelle mit dem Index SIZE-1.
1. Vor¨uberlegungen
Bubble Sort macht nichts anderes als wir uns im Quiz-Teil dieses ¨Ubungspakets erarbeitet haben: Er geht das zu sortierende Array elementweise durch, vergleicht zwei Nachbarn und vertauscht diese gegebenenfalls. Dadurch kommt das gr¨oßte Element ans Ende. Dieser Vorgang wird dann insgesamt maximal SIZE-1 mal wiederholt.
Anschließend ist das Array definitiv sortiert. Um aus
”Glauben“ Wissen zu machen, machen wir hier eben noch eine Handsimulation (verk¨urzt, jeweils am Ende eines vollst¨andigen Durchlaufs):
Durchlauf a[ 0 ] a[ 1 ] a[ 2 ] a[ 3 ]
0 4711 27 42 2
1 . . . . . . . . . . . . . . . .
2 . . . . . . . . . . . . . . . .
3 . . . . . . . . . . . . . . . .
2. Aufgabenstellung
Entwickle ein Programm, das die Elemente eines eindimensionalen Arrays aufstei-
4. Testdaten
Als Testdaten k¨onnen wir die Beispiele aus dem Quiz-Teil ¨ubernehmen.
5. Implementierung
6. Kodierung
7. Erweiterung I
Die erste Erweiterung besteht darin, dass das Programm die zu sortierenden Daten selbstst¨andig einliest. Wie das geht, haben wir bereits besprochen.
8. Erweiterung II
Im Quizteil haben wir gesehen, dass wir die Zahl der Vergleiche in jedem Durchlauf um eins reduzieren k¨onnen. Hierzu m¨ussen wir die Laufvariablen der ¨außeren Schleife in der Bedingung der inneren Schleife ber¨ucksichtigen. In der Musterl¨osung geschieht dies in Zeile13durch die Variablei. F¨uhre die entsprechenden Erweiterungen durch.
Aufgabe 2: Suchen in unsortierten Tabellen
Eine zweite Standardaufgabe besteht darin, dass ein Programmteil ¨uberpr¨uft, ob ein be- stimmter Wert in einem Array vorhanden ist oder nicht. Diese Aufgabe ist mit dem Nach- schlagen einer Telefonnummer in einem (elektronischen) Telefonbuch vergleichbar. In dieser Ubungsaufgabe wenden wir uns einem sehr einfachen Fall zu, um uns das Grundkonzept¨ einmal zu erarbeiten.
1. Aufgabenstellung
Wir nehmen an, dass wir ein Array haben, das mit Daten gef¨ullt ist. Wir nehmen fer- ner an, dass dieses Array unsortiert ist (ja, wir k¨onnten es mit unseremBubble Sort Algorithmus mal eben sortieren). Entwickle nun ein Programmst¨uck, das ¨uberpr¨uft, ob ein angegebener Wert in diesem Array vorhanden ist oder nicht.
Beispiel: Wir nehmen an, wir haben folgende Daten: 4711,27,42 und 2 Eingabe: 27 Ausgabe: 27 ist vorhanden, Index=1
Eingabe: 25 Ausgabe: 25 ist nicht vorhanden Quizfrage: Welche Anweisung bricht eine for-Schleife fr¨uhzeitig ab?
2. Pflichtenheft: Aufgabe, Eingabe, Ausgabe, Sonderf¨alle
3. Testdaten
Als Testdaten nehmen wir obige Werte zuz¨uglich weiterer beliebiger Ganzzahlen.
4. Implementierung
5. Kodierung
