Datenstrukturen: Arrays, Listen und Bäume Standardalgorithmen: Suchen und Sortieren Dateiverwaltung Seite 1 Was ist ein array? Vektor (eindimensionales Feld) a 1 a 2 a 3 a 4... a n Matrix (zweidimensionales Feld) m 1,1 m 1,2 m 1,3... m 1,r m 2,1 m 2,2 m 2,3... m 2,r... m s,1 m s,2 m s,3... m s,r Datenfelder (arrays) geordnete Zusammenfassung von Datenelementen gleichen Datentyps (int, float, char,...); auch mehr als zweidimensional zulässig direkter Zugriff über Indices; Adressrechnung notwendig Seite 2
Array-Datentyp Datentyp: entspricht dem Datentyp der Elemente Vereinbarung: Name des arrays + Anzahl der Elemente + deren Datentyp Zugriff: über Indices (Adress-Rechnung) oder Zeiger Beispiel: Vereinbarung: float werte[20][3]; Zugriff: werte[12][2] Seite 3 Vereinbarung von arrays Funktion: reserviert Speicherplatz für die angegebene Anzahl Elemente im entsprechenden Datentyp Index des 1. Elementes in der Programmiersprache C ist immer 0; alsein mit x[10] vereinbartes Array enthält die Elemente x[0], x[1],..., x[9] Beispiele: int x[10]; char satz[40]; float matrix[100][20], tabelle[12][4]; Seite 4
Daten-Eingabe in arrays nur möglich unter Benutzung von Zyklen zur Eingabe von Werten in die einzelnen Elemente: for-anweisung bei bekannter, fester Anzahl von Elementen while-anweisung bei unbekannter, variabler Anzahl Test einer Abbruchbedingung (am Anfang absichern!) do-anweisung Test der Abbruchbedingung am Ende Seite 5 Zugriff zu array-elementen Zugriff erfolgt über einen Index bzw. mehrere Indices Zuweisung: x[3] = a*c1 +...; in Ausdrücken: anzahl = x[1]+x[2]: Seite 6
Anwendungsbeispiele Verarbeitung von Tabellen / Matrizen Sortieren: BubbleSort SelectionSort... Statistische Methoden: Datenauswertungen Abweichungen von statistischen Maßen Regressionsanalyse Seite 7 Anwendung von Arrays SelectionSort Struktogramm Verarbeitung Eingabe Ausgabe LIES (anzahl); für i von 1 bis anzahl LIES (zahl[i]); für j von 1 bis (anzahl-1) min=zahl[j]; pos=j; für i von (j+1) bis anzahl zahl[i]<min ja? nein min=zahl[i]; pos=i; zahl[pos]=zahl[j]; zahl[j]=min; für i von 1 bis anzahl SCHREIBE (zahl[i]); Seite 8
Anwendung von Arrays SelectionSort #include <stdio.h> void main() { int min, pos; // Minimum, Position von min int i,j,anz; // Index, Anzahl der Zahlen int zahl[50]; // indizierte Zahlenwerte printf("wieviele Zahlen? = "); // unsortiert einlesen scanf("%d",&anz); for (i=0; i<anz; i++) { printf("%2i : ",i+1); scanf("%i", &zahl[i]); } for (i=0; i<anz-1; i++) { // Sortierung min=zahl[i]; pos=i; for (j=i+1; j<anz; j++) if (zahl[j]<min) { min=zahl[j]; pos=j; } zahl[pos]=zahl[i]; zahl[i]=min; } printf ("\n\nsortiert:\n"); // sortiert ausgeben for (i=0; i<anz; i++) printf("%2i : %6i\n", i+1, zahl[i]); } Seite 9 Zeichenketten Speicherung in Vektoren vom Typ char variable Länge durch Abschlusszeichen '\0' (ASCII-Code 0) gekennzeichnet; Elemente nach dem Abschlusszeichen haben undefinierten Inhalt in C keine Operatoren für Zeichenkettenverarbeitung vorhanden, aber in der C-Bibliothek string.h existieren zahlreiche Routinen Seite 10
Vereinbarung von Zeichenketten Vereinbarung als Vektoren vom Typ char Beispiele: char str[50]; char name[20] = "Meier"; Seite 11 Verarbeitung von Zeichenketten Ein- und Ausgabe: formatierte Ein- und Ausgabe mit Format "%s" Beispiel: scanf ("%s", str); kein & vor dem Bezeichner! printf ("%s", str); Zugriff auf einzelne Zeichen: elementweise analog Vektoren Routinen für die Verarbeitung (in string.h enthalten): strcat verbindet zwei Strings zu einem strchr sucht ein bestimmtes Zeichen im String strcmp vergleicht zwei Zeichenketten lexikographisch strcpy kopiert einen String auf einen String Seite 12
Dynamische Datenstrukturen Array statische Datenstruktur Größe muss bei Definition bekannt sein und bleibt konstant gesamter Speicherplatz bleibt reserviert, auch wenn nicht benutzt direkter Zugriff, wenn Position bekannt, sonst sequentielle Suche Einfügen mitten in Array nur nach Verschiebung der nachfolgenden Elemente möglich Löschen eines Elementes hinterlässt freien Speicherplatz; problematisch Schlussfolgerung: für viele Aufgaben nicht gut geeignet Ausweg: Dynamische Datenstrukturen, z.b. Listen und Bäume Seite 13 Lineare Liste Begriffe first key next key next key NULL Eigenschaften: sequentielle Verkettung von Datensätzen Ordnungsprinzip: Schlüssel (key) Speicherbedarf wächst mit der Größe der Liste; leere Liste braucht nur first Begriffe: first - Anker, Wurzel; Adresse des logischen Listenanfangs key - Schlüssel; Ordnungskriterium next - Adresse des logischen Nachfolgers - Datensatz-Inhalt NULL - leere Adresse; logisches Ende der Liste Seite 14
Lineare Liste Beispiel *Biber Biber *Dachs Dachs *Habicht Habicht *Maus Maus *Uhu Uhu NULL Seite 15 Operationen in linearen Listen Einfügen am Anfang *Adler Adler *Biber Algorithmus: Speichern des neuen Listenelementes auf beliebigen freien Speicherplatz Adresse der bisherigen Wurzel in next des neuen Listenelementes eintragen Adresse des neuen Listenelementes in first eintragen Biber *Dachs Dachs *Habicht Habicht *Maus Maus *Uhu Uhu NULL Seite 16
Operationen in linearen Listen Einfügen innerhalb der Liste Adler *Biber Katze *Maus *Adler Biber *Dachs Dachs *Habicht Algorithmus: Speicherung des neuen Elementes auf beliebigen freien Speicherplatz Suchen der Einfügestelle (sequentielles Durchlaufen der Liste) Adresse des logischen Nachfolgers aus next des logischen Vorgängers in next des neuen Elementes eintragen Adresse des neuen Elementes in next des logischen Vorgängers eintragen Habicht *Katze Maus *Uhu Uhu NULL Seite 17 Operationen in linearen Listen Einfügen am Ende der Liste *Adler Adler *Biber Biber *Dachs Dachs *Habicht Habicht *Katze Algorithmus: Speicherung des neuen Elementes auf beliebigen freien Speicherplatz Suchen der Einfügestelle (sequentielles Durchlaufen der Liste) Adresse NULL aus next des logischen Vorgängers in next des neuen Elementes eintragen Adresse des neuen Elementes in next des bisherigen logisch letzten Elementes eintragen Katze *Maus Maus *Uhu Uhu *Zebra Zebra NULL Seite 18
Operationen in linearen Listen Löschen eines Elementes der Liste *Adler Adler *Biber Biber *Dachs Dachs *Katze Algorithmus: Suchen des zu löschenden Elementes (sequentielles Durchlaufen der Liste) Adresse des logischen Nachfolgers des zu löschenden Elementes aus next dieses Habicht *Katze Elementes in next des logischen Vorgängers eintragen (anstelle der Adresse des zu löschenden Elementes) Speicherplatz des gelöschten Elementes freigeben Katze *Maus Maus *Uhu Uhu *Zebra Zebra NULL Seite 19 Lineare Liste Implementierung Voraussetzung: Direktzugriffsspeicher Notwendiger Speicherplatz: für n Datensätze zu je m Bytes = n*m Bytes Speicherplatz für Anker Verwaltung des Speichers durch Programm durch Betriebssystem Satzaufbau: Schlüsselattribut key Satzinhalt / Daten Zeiger auf logisch nächsten Datensatz next Seite 20
Lineare Liste Probleme aufwändiges Durchsuchen: Rückwärtsverkettung zusätzlich, Mehrfachverkettung Speicherverwaltung der leeren Datensätze: Bitmap (1 bit/datensatz) oder Lineare Liste freier Datensätze (Ankeradresse + Kettung der leeren Datensätze) oder...? logische Reihenfolge entspricht nicht physischer Reihenfolge: Reorganisation = Herstellen der Übereinstimmung von logischer und physischer Folge Seite 21 Binärer Suchbaum besteht aus Knoten mit genau einem Eingang und max. zwei Ausgängen Ordnung im Baum: nach Schlüsselwerten der jeweiligen Knoten alle Knoten haben links von einem Knoten kleinere, rechts größere Schlüsselwerte als der Ausgangsknoten 46 22 84 19 34 72 94 11 20 31 36 61 75 85 99 Seite 22
Binärbäume Begriffe Baum (tree) = endlicher, schwach zusammenhängender Graph, für dessen Knoten gilt: genau ein Knoten hat keinen Eingang (Wurzel, root) alle anderen Knoten haben genau einen Eingang endlicher Graph = Menge Knoten N (nodes) + Menge Kanten E (edges) Binärer Baum (binary tree) = geordneter Baum, der leer ist oder für dessen Knoten gilt: außer den Endknoten haben alle Knoten genau zwei Ausgänge maximal ein "Kind" jedes "Elternknotens" ist leer Seite 23 Binärbäume Begriffe Vollständiger Baum: alle Knoten besetzt Tiefe 0 Tiefe 1 3 5 Wurzel 7 Unterbaum Unausgeglichener Baum: ungleiche Tiefe Direkter Nachfolger Vorgänger 5 3 6 7 19 Tiefe 2 1 4 6 9 Blätter 1 4 Ausgeglichener Baum: beide Äste gleiche Tiefe oder max. eine Ebene Unterschied 5 7 Brüder 19 4 6 8 2 Seite 24
Binärer Suchbaum Erzeugen Ausgangspunkt: Folge von Werten Beispiel: 46 84 94 22 72 19 20 34 36 61 99 85 75 11 31 46 22 84 19 34 72 94 11 20 31 36 61 75 85 99 Seite 25 Binärer Suchbaum Hinzufügen Hinzufügen: 29 3 52 87 60 (in dieser Reihenfolge) Algorithmus: Durchlaufen des Baumes bis zu einem Blatt Anhängen des neuen Knotens 46 22 84 19 34 72 94 11 20 31 36 61 75 85 99 3 29 52 87 60 Seite 26
Binärer Suchbaum Löschen Algorithmus: Durchlaufen des Baumes bis zum zu löschenden Knoten Fallunterscheidung: Endknoten Knoten mit nur einem Nachfolger: Nachfolger ersetzt den zu löschenden Knoten Knoten mit zwei Nachfolgern: "größter" Knoten im "linken" Unterbaum bzw. "kleinster" Knoten im "rechten" Unterbaum ersetzt den zu löschenden Knoten Seite 27 Binärer Suchbaum Suchen / Durchlaufen Algorithmus: Durchlaufen des Baumes bis zum gesuchten Knoten oder zu einem Blatt (= "nicht gefunden") Beispiel: maxtiefe = 20 Anzahl der Knoten eines Baumes: n B = 2 (maxtiefe + 1) -1 2.097.151 Durchschnittliche Anzahl der Zugriffe: v B = ( maxtiefe+1) / 2 10,5 Anzahl der Zugriffe in einer Liste (zum Vergleich): v L = ( n L + 1 ) / 2 1.048.576 Seite 28
Suchverfahren Begriffe Suchen = Bestimmen der Position (Adresse) eines Wertes in einer Datenfolge Sequentielles Suchen einfachstes Suchverfahren keine Vorbedingungen (Ordnung) notwendig hoher Suchaufwand: im Durchschnitt n/2 Zugriffe für eine n-elementige Datenmenge Seite 29 Suchverfahren Binäre Suche Voraussetzung: sortierte Folge Algorithmus: 1. Anfangsindex first=1; Anzahl der Werte n 2. Test des Wertes "in der Mitte" der Folge, also bei Position m = (first + n/2) 3. Ist das der gesuchte Wert: Ende 4. Ist der gesuchte Wert größer, dann Ausschluss des Bereiches von Position first bis (first + n/2): first = first + n/2; n=(n+1)/2 sonst Ausschluss des Bereiches von Position (first + n/2) bis n: n=(n+1)/2 5. Wiederhole ab Schritt 2. Seite 30
Suchverfahren Binäre Suche Beispiel: gesucht 45 in der vorliegenden Folge 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 6 9 12 24 45 46 47 58 62 71 73 88 94 102 106 2. Zugriff 4. Zugriff: gefunden 3. Zugriff 1. Zugriff Seite 31 Daten sortieren verschiedene Sortierverfahren 167 817 395 291 103 444 221 141 386 257 SelectionSort 167 103 817 141 395 167 291 221 103 167 395 257 444 291 221 291 444 386 141 817 395 386 444 257 395 817 BubbleSort 167 817 395 395 817 291 291 817 103 103 817 444 444 817 221 221 817 141 141 817 386 386 817 257 257 817 Seite 32
Sortierverfahren SelectionSort 0 1 2 3 4 5 6 7 8 9 36 29 27 74 41 11 29 27 74 41 11 16 27 74 41 11 16 22 74 41 11 16 22 27 41 11 16 22 27 29 11 16 22 27 29 11 16 22 27 29 11 16 22 27 29 11 16 22 27 29 16 63 22 11 52 16 63 22 36 52 29 63 22 36 52 29 63 27 36 52 29 63 74 36 52 41 63 74 36 52 36 63 74 41 52 36 41 74 63 52 36 41 52 63 74 36 41 52 63 74 Seite 33 Sortierverfahren SelectionSort Algorithmus für Sortierung in aufsteigender Folge: 1. Setze den Anfangszeiger auf das (absolut) 1. Element der Folge. 2. Durchsuche die Folge vom (aktuellen) Anfangszeiger bis zum Ende nach dem kleinsten Element und merke Dir dessen Position und Wert. 3. Vertausche das (jeweils) 1. Element der Suchfolge mit dem kleinsten; dieses steht damit in der sortierten Folge an der "richtigen Stelle". 4. Setze den Anfangszeiger um eine Position weiter, auf das nunmehr 1. Element der verbleibenden Folge. 5. Wiederhole die Schritte 2. bis 5. solange, bis der Anfangszeiger auf das vorletzte Element zeigt; die Folge ist dann sortiert. Seite 34
Sortierverfahren SelectionSort void SelectionSort (int arr[], long int anz) { int min; long int h, k, pos; } for (h=0; h<anz-1; h++) { min = arr[h]; pos = h; for (k=h+1; k<anz; k++) { if (arr[k] < min) { min = arr[k]; pos = k; } } arr[pos] = arr[h]; arr[h] = min; } Seite 35 Sortierverfahren BubbleSort 1 36 29 27 74 41 29 36 27 74 41 29 27 36 74 41 29 27 36 74 41 29 27 36 41 74 29 27 36 41 16 29 27 36 41 16 29 27 36 41 16 29 27 36 41 16 29 27 36 41 16 16 63 22 11 52 16 63 22 11 52 16 63 22 11 52 16 63 22 11 52 16 63 22 11 52 74 63 22 11 52 63 74 22 11 52 63 22 74 11 52 63 22 11 74 52 63 22 11 52 74 Seite 36
Sortierverfahren BubbleSort 0 1 2 3 4 5 6 7 8 9 36 29 27 74 41 29 27 36 41 16 27 29 36 16 41 27 29 16 36 22 27 16 29 22 11 16 27 22 11 29 16 22 11 27 29 16 11 22 27 29 11 16 22 27 29 11 16 22 27 29 16 63 22 11 52 63 22 11 52 74 22 11 52 63 74 11 41 52 63 74 36 41 52 63 74 36 41 52 63 74 36 41 52 63 74 36 41 52 63 74 36 41 52 63 74 36 41 52 63 74 Seite 37 Sortierverfahren BubbleSort Algorithmus für Sortierung in aufsteigender Folge: 1. Setze den Anfangszeiger auf das 1. Element der Folge. 2. Setze die "Tauschkennung" auf 0. 3. Vergleiche das 1. und das 2. Element der Folge. 4. Falls das (jeweils) 2. kleiner ist als das (jeweils) 1., vertausche beide miteinander und erhöhe die "Tauschkennung". 5. Wiederhole Schritt 3. und 4. für alle Elementpaare der Folge. 6. Wiederhole die Schritte 1. bis 5. für die unsortierte Teilfolge, solange die "Tauschkennung" nach Durchlaufen der Schritte 3. bis 5. größer 0 ist oder aber (n-1) Durchläufe erreicht sind. Verbessungsmöglichkeiten: abwechselnd von vorn und von hinten beginnen Kombination von beiden Seite 38
Sortierverfahren BubbleSort void BubbleSort (int arr[], long int anz) { int tausch, hilf; long int k; } do { tausch = 0; for (k=0; k<anz-1; k++) { if (arr[k+1] < arr[k]) { hilf = arr[k]; arr[k] = arr[k+1]; arr[k+1] = hilf; tausch++; } } anz--; } while (tausch); Seite 39 Vergleich der Sortierverfahren Animation: http://www.inf.hs-anhalt.de/~worzyk/iin/applets.htm E:\modul_04_cd\Lektion_do06\text\Java\sortAlgorithms.html Seite 40
Sortierverfahren Bewertung Experimentelle Untersuchung: Erzeugung unterschiedlicher Mengen zufallsverteilter Ausgangsdaten Zeitmessung, bezogen auf den reinen Sortiervorgang, für verschiedene Datenmengen und verschiedene Sortierverfahren statistische Auswertung Theoretische Untersuchung: Analyse des Aufwandes (Speicherplatz-, Rechenzeitbedarf) in Abhängigkeit von der zu sortierenden Datenmenge Seite 41 Sortierverfahren Zeitmessungen Erzeugen unsortierter Daten Start- und Endzeit messen Versuchsparameter: Sortierverfahren zu sortierende Menge Rechnerleistung Reproduzierbarkeit gewährleisten statistische Auswertung Seite 42
Datenspeicherung Arbeitsspeicher ist flüchtig, enthält die Daten nur während der Verarbeitung (Laufzeit des jeweiligen Programms) dauerhafte Speicherung auf Datenträger, z.b. Platte, Diskette, CD-ROM, DVD, USB-Stick, Magnetband,... Speicherung als Datei, vom Betriebssystem verwaltet Dateitypen: sequentielle Dateien: Schreiben und Lesen in gleicher, feststehender (sequentieller) Reihenfolge Direktzugriffsdateien: Schreiben und Lesen in beliebiger (wahlfreier) Reihenfolge; zum Zugriff Beziehung zwischen Daten (Schlüssel) und Speicheradresse notwendig Seite 43 Probleme der Dateiarbeit jede Datei hat eigene Struktur für alle Datei-Operationen (Hinzufügen, Löschen, Ändern, Suchen,...) je Dateistruktur eigene Programme notwendig; jede Dateistruktur-Änderung hat Änderungen bei allen Programmen zur Folge, die diese Datei nutzen keine Unabhängigkeit von Daten und Programmen Mehrfachnutzung von gleichen Daten wird behindert Ausweg: Datenbanksysteme Seite 44
Kontrollfragen 1. Wozu dienen Arrays? Wie werden sie eingelesen, wie verarbeitet und wie ausgegeben? 2. Was ist eine Zeichenkette? Wir sie eingelesen, verarbeitet und ausgegeben? 3. Was verstehen Sie unter dynamischen Datenstrukturen? 4. Wie ist eine Liste organisiert und was nützt sie? 5. Wie ist ein binärer Suchbaum organisiert und wozu wird er verwendet? 6. Welche unterschiedlichen Sortierverfahren kennen Sie und wie funktionieren sie? 7. Wie kann man Leistungsparameter von Sortier-Algorithmen bestimmen? 8. Wie werden Daten auf externen Speichern abgelegt und welche Probleme können dabei entstehen? Seite 45