10. Fortgeschrittene Programmiertechniken Fortgeschrittene Programmiertechniken

Transkript

1 Fortgeschrittene Programmiertechniken 10-1

2 Zu den fortgeschrittenen Techniken gehören: Verwendung von komplexeren Datenstrukturen, z. B. von geschachtelten Strukturen, Baumstrukturen usw. Verwendung von vordefinierten und/oder standardisierten Algorithmen, z. B. Such- und Sortieralgorithmen Verwendung der Rekursion in Daten und Kontrollstrukturen Verwendung von speziellen Datenorganisationen, z. B. Hash-Tabellen und hash-verfahren Verwendung von objektorientierten Programmiertechniken Softwareagenten-Technologien u. v. a. 10-2

3 Geschachtelte Strukturen a) stufenweise Definition: #define STUD_ANZAHL Fortgeschrittene Programmiertechniken struct gruppe { /* Komponenten */ int fachrichtung; int semester; int matrikelnummer; ; struct name { char nachname [20]; char vorname [16]; ; 10-3

4 struct geburtsdatum { int jahr; int monat; int tag; ; 10. Fortgeschrittene Programmiertechniken struct student { /* Deklaration der Schablone "Student" */ struct gruppe bezeichnung; struct name familienname; struct geburtsdatum g_datum; ; struct student tab_stud [STUD_ANZAHL]; /* Definition der Tabelle für Daten von Studenten */ 10-4

5 b) inline Definition: #define STUD_ANZAHL 550 struct student { struct gruppe { int fachrichtung; int semester; int matrikelnummer; ; struct name { char nachname [20]; char vorname [16]; ; struct geburtsdatum { int jahr; int monat; int tag; tab_stud [STUD_ANZAHL]; 10-5

6 Zugriff zu den Komponenten (Beispiele): struct student *rn, *rq; struct name person_name; /* Variablen für Demo */ struct geburtsdatum dat; int geburtsjahr, geb_j2; char *surname;... rn = tab_stud; /* Adressenzuweisungen */ rq = &tab_stud[i]; person_name = (rn+i)->familienname; /* Wertzuweisungen */ dat = (rn+i)->g_datum; geburtsjahr = (rn+i)->g_datum.jahr; strcpy (surname, (rn+i)->familienname.nachname); geb_j2 = rq->g_datum.jahr /* oder rq = (*rq).datum.jahr */ 10-6

7 Suchverfahren direkte Suche binäre Suche Fibonacci Suche 10. Fortgeschrittene Programmiertechniken Merkmale elementarer Suchverfahren Schlüssel sind eindeutig, d.h. es gibt keine Mehrfachtreffer Die Schlüsselmenge besitzt eine lineare Ordnung Es sind nur Schlüsselvergleiche erlaubt Ergebnis einer Suche ist das gefundene Item oder eine Fehlanzeige 10-7

8 Direkte Suche 10. Fortgeschrittene Programmiertechniken im Text int SearchTxt (char *s, char *p) { int n, m; // String - Musterlänge int i, j; // Suchzeiger unsigned int found; // Flag: 1 == gefunden, 0 == nicht gefunden n = strlen(s); m = strlen(p); for (i=0; i<n-m+1; i++) { found = 1; for (j=0; j<m; j++) if (s[i+j]!= p[j]) found = 0; if (found == 1) return (i); return(-1); 10-8

9 in Feldern // SearchSeq: Sequentielles Suchen in einem Array // Parameter: A Zahlenfeld, in dem gesucht wird // n Anzahl der gültigen Feldelemente // item gesuchtes Element // int SearchSeq (int *A, int n, int item) { int i; // Laufvariable A[0] = item; // Stopper-Element besetzen i = n + 1; // An das rechte Ende zeigen while (item!= A[--i]); // Von rechts suchen return (i); // Index des Item oder 0 zurückliefern 10-9

10 in Tabellen int seq_search (int key, item *t, item *result, int p) /* Funktion seq_search für seq. Suche in der Tabelle t */ /* Parameter: key - Schlüssel der gesuchten Ware, t - Name der durchgesuchten Tabelle, result - Zeiger auf die Speicherzone, auf die das gesuchte Item abgespeichert werden soll, p - Länge der Tabelle */ /* Funktionswert: 0, wenn das Item gefunden war, -1, wenn nicht */ { int i; /* Variable für Indizes */ for (i=0; i<p; i++) if (t[i].num == key) { *result = t[i]; /* Item gefunden */ return (0); return (-1); /* Item nicht gefunden */ 10-10

11 Binäre Suche Prinzip: Halbierung des Feldes Bedingung: Das durchgesuchte Feld muss geordnet werden! int bin_search (int key, item *t, item *result) /* Funktion bin_search für binäre Suche in der Tabelle t */ /* Parameter: key - Schlüssel der gesuchten Ware, t - Name der durchgesuchten Tabelle, result - Zeiger auf die Speicherzone */ /* Funktionswert: 0, wenn das Item erfolgreich gefunden, -1, wenn das Item nicht gefunden war */ { int m, left, right; /* Variablen für Indizes */ left = 0; /* Initialisierung von Suchgrenzen */ right = N-1; 10-11

12 while (left<=right) { /* Ende - Bedingung */ m = (left+right) / 2; /* Mitte des Intervals */ if (t[m].num < key) left = m+1; /* Suche in der höheren Hälfte */ else if (t[m].num > key) right = m-1; /* in der unteren Hälfte */ else if (t[m].num == key) { *result = t[m]; /* Item gefunden */ return (0); else return (-1); /* Item nicht gefunden */ 10-12

13 Fibonacci Suche Prinzip: Aufteilung des Feldes nach Fibonacci Zahlen Bedingung: Das durchgesuchte Feld muss geordnet werden! 10-13

14 Beispiel: 10-14

15 Sortierverfahren 10. Fortgeschrittene Programmiertechniken direkte versus indirekte Verfahren interne versus externe Verfahren sequentielle versus parallele Verfahren fortgeschrittene und kombinierte Verfahren Merkmale elementarer Sortierverfahren Sie nutzen keine Eigenschaften der Datenstruktur aus Sie verwenden als Operationen nur Schlüsselvergleiche und Transporte Sie besitzen eine relativ hohe Komplexität O(N 2 ) Komplexitätrelevante Operationen Vergleiche (Comparisons) Transport-Operationen (Movements) 10-15

16 Beispiele elementarer Sortierverfahren: das Selection-Sort Verfahren das Insertion-Sort Verfahren das Shell-Sort Verfahren Das Bubble-Sort Verfahren Beispiele spezieller Sortierverfahren: das Quick-Sort Verfahren das Heap-Sort Verfahren das Merge-Sort Verfahren Das Radix-Sort Verfahren 10-16

17 Beispiel das Bubble-Sort Verfahren: /* */ /* Bubble Sort - Sortieren durch lokales Vertauschen */ /* */ void BubbleSort (elem F[], int L) { /* F... das zu sortierende Feld von Items */ /* L... Zahl von sortierten Feldelementen */ int j; /* "Zeiger" in die zu sortierende Liste */ elem Item; /* Zwischenspeicher zum Vertauschen */ int XCHG; /* TRUE, wenn eine Vertauschung vorkam */ /* L... letzte Position der aktuellen Teilliste */ 10-17

18 do { /* XCHG zeigt an, ob bei dieser Teilliste eine */ XCHG = 0; /* Vertauschung vorgenommen werden musste */ for (j=0; j<l; j++) /* aktuelle Teilliste durchlaufen,dabei vertauschen */ if (F[j].key > F[j+1].key) { Item = F[j]; /* Vertausch */ F[j] = F[j+1]; F[j+1] = Item; XCHG = 1; L--; while (XCHG); /* läuft solange zwei Elemente vertauscht wurden */ 10-18

19 2. Variante mit Zeigern: 10. Fortgeschrittene Programmiertechniken void BubbleSort (elem *F, int L) /* F... Zeiger auf das zu sortierende Feld von Items */ /* L... Zahl von sortierten Feldelementen */ { elem *H; /* Zeiger auf das zu sortierende Feld */ elem Item; /* Zwischenspeicher zum Vertauschen */ int XCHG; /* TRUE, wenn eine Vertauschung vorkam */ /* L... letzte Position der aktuellen Teilliste */ do { XCHG = 0; /* XCHG zeigt an, ob bei dieser Teilliste */ /* eine Vertauschung vorgenommen werden musste */ 10-19

20 for (H=F; H<F+L; H++) /* aktuelle Teilliste */ /* durchlaufen und vertauschen */ if (H->key > (H+1)->key) { Item = *H; /* Vertausch */ *H = *(H+1); *(H+1) = Item; XCHG = 1; L--; while (XCHG); /* läuft solange zwei Elemente vertauscht wurden */ 10-20

21 Beispiel das Shell-Sort Verfahren: int shellsort (int v[], int n) { int gap, i, j, temp; /* v[0].. v[n-1] aufsteigend sortieren */ for (gap = n/2; gap > 0; gap /= 2) for (i = gap; i < n; i++) for (j =i-gap; j>=0 && v[j]>v[j+gap]; j-=gap) { temp = v[j]; v[j] = v[j+gap]; /* Items wechseln */ v[j+gap] = temp; 10-21

22 Rekursion 10-22

23 Rekursion 10. Fortgeschrittene Programmiertechniken in Datenstrukturen (rekursiv definierte Strukturen) Listen L w 1 w 2 w 3 w 4 w 5 Deklaration (Schablone): struct list_el { /* Struktur Listenelement */ ; int wert; struct list_el *next; 10-23

24 Bäume 10. Fortgeschrittene Programmiertechniken Kurt Franz Rolf Dieter Hans Leo W Werner Erich Karl 10-24

25 Definition des Knotens: Kurt linker Sohn rechter Sohn Deklaration (Schablone): struct knoten { char *inhalt; /* diesmal Zeiger auf String */ struct knoten *links, *rechts; ; 10-25

26 in Algorithmen (Programmen) Jedes Verfahren kann in allgemein folgendermaß definiert werden: P = ( S i, P ) Jeder rekursive Aufruf muss aber durch Erfüllung einer Bedingung beendet werden, d.h. oder besser P = if B then ( S i, P ), P = ( S i, if B then P )

27 Beispiel: Berechnung der Fakultät-Funktion long fak_rek (int n) { if (n > 1) return (n * fak_rek (n-1)); else return (n); ohne Rekursion: long fak_it (int n) { int i; long f = 1; if (n > 1) { for (i=1; i<=n; i++) f *= i; return (f); else return (n); 10-27

28 Inhalt des Binärbaumes sortiert ausgeben: Definition: struct knoten { char *inhalt; /* diesmal Zeiger auf String */ struct knoten *links, *rechts; *Baum; Algorithmus der Ausgabe: void Ausgeben (struct knoten *B) { /* Baum B ausgeben */ if (B!= NULL) { Ausgeben (B->links); printf ("%s, ", *(B->inhalt)); Ausgeben (B->rechts); 10-28

29 Hanoi Türme: /********************************************************** * Türme von Hanoi: Ausgabe der Züge für diese Türme * **********************************************************/ void turm (char quelle, char hilf, char ziel, int k) { if (k==1) /* Ende der Rekursion */ printf (" %c -> %c\n", quelle, ziel); else { turm (quelle, ziel, hilf, k-1); printf (" %c -> %c\n", quelle, ziel); turm (hilf, quelle, ziel, k-1); 10-29

30 Rekursives Sortierverfahren Quick-Sort quicksort (int a[], int left, int right) { /* aufsteigend sort. */ int i, j, pivot, temp; i = left; j = right; pivot = a[(left+right)/2]; do { while (a[i] < pivot) i++; while (a[j] > pivot) j--; if (i <= j) { temp = a[i]; a[i] = a[j]; /* Items wechseln */ a[j] = temp; i++; j--; while (i <= j); if (left < j) quicksort (a, left, j); if (i < right) quicksort (a, i, right); 10-30

31 Zusammenfassung 10. Fortgeschrittene Programmiertechniken Verwendung von mehrfach strukturierten Datenobjekten sowie auch standardisierten Algorithmen und Methoden (Suchverfahren, Sortierverfahren usw.) vereinfacht das Schreiben von Programmen und erhöht ihre Übersichtlichkeit. Mehrheit von effizienten Suchalgorithmen (binäre Suche, Fibonacci-Suche u.v.a.) verlangt das Sortieren (Aneinanderreihung) des Suchraumes nach dem Suchschlüssel. Wenn die zu durchsuchenden Daten nach dem Schlüssel nicht sortiert sind, ist nur der Algorithmus der sequentiellen Suche zu verwenden. Direkte und indirekte Sortiermethoden sind zu verwenden. Direkte Methoden ändern die physische Aneinanderreihung von Daten, indirekte Methoden benutzen zur Aneinanderreihung verschiedene Hilfsstrukturen (Adressierungsvektoren oder -tabellen, verkettete Listen, Baumstrukturen usw.)

32 Verwendung von Sortiermethoden ist vom Vorsortieren der zu sortierenden Datenfolgen abhängig. Verwendung der Rekursion vereinfacht wesentlich die Zerlegung von Verarbeitungsverfahren und die Erzeugung von Programmen. Es ist die Rekursion in Datenstrukturen und in Kontrollstrukturen (Programmen, Prozeduren, Funktionen,...) zu unterscheiden. Rekursive Algorithmen und Programme sind sehr übersichtlich, aber ihre Verarbeitungskomplexität ist often höher, als bei den klassischen (sequentiellen oder iterativen) Programmstrukturen. Verwendung der Rekursion in Kontrollstrukturen (Programmen) ist meistens berechtigt, falls die benutzten Datenstrukturen auch rekursiv definiert werden (Algorithmen der Suche in Listen, Bäumen, usw.)