Informatik II Grundlagen der Programmierung Programmieren in C Module und Bibliotheken 3 Hochschule...

Informatik IIGrundlagen der Programmierung

Programmieren in C

Module und Bibliotheken 3

Hochschule Fulda – FB ET

Sommersemester 2010

http://www.rz.hs-fulda.de/et

Peter Klingebiel, HS Fulda, DVZ

http://www.rz.hs-fulda.de/et

Programmieren in C - Peter Klingebiel - HS Fulda - DVZ 2

Sortieren 1

• Sortieren von Zahlen, Strings, allgemein von Daten, ist oft auftretende Aufgabenstellung

• Meist: Daten sind in Feldern vorhanden Sortieren von Feldelementen• Intuitiver Algorithmus:

– Feld von oben nach unten (oder von links nach rechts) durchlaufen und elementweise sortieren

– Feld solange immer wieder durchlaufen, bis Feld sortiert ist

Bubblesort-Algorithmus• http://de.wikipedia.org/wiki/Bubblesort

http://de.wikipedia.org/wiki/Bubblesort


Sortieren 2

• 1. Durchlauf bei Bubblesort


Sortieren 3


Sortieren 4

die größten Elemente wandern nach und nach an das Ende des Feldes

steigen wie Blasen auf Bubblesort• Algorithmus für int-Feld mit n Elementen:

void bsort(int v[], int n)

int i, j;

for(i = 0; i < n; i++) for(j = 0; j < n-i-1; j++) if(v[j] > v[j+1])

swap(v, j, j+1);


Sortieren 5

• Bubblesort für Feld von Strings


Sortieren 6

• Sortierprogramm für Strings


Sortieren 7

• Diskussion– Stabilität?– Geschwindigkeit?


Sortieren 8

• Schnellerer Algorithmus Quicksort• rekursiver Algorithmus für int-Feld

void qsort(int v[], int left, int right)

int i, last;

if(left >= right) return; swap(v, left, (left + right) / 2); last = left; for(i = left + 1; i <= right; i++) if(v[i] < v[left]) swap(v, ++last, i); swap(v, left, last); qsort(v, left, last - 1); qsort(v, last + 1, right);


Sortieren 9

• Prinzip: teile und herrsche

• http://de.wikipedia.org/wiki/Quicksort

http://de.wikipedia.org/wiki/Quicksort


Sortieren 10

• Quicksort für Feld von Strings


Sortieren 11

• Sortierprogramm für Strings


Sortieren 12

• Diskussion– Stabilität?– Geschwindigkeit?


Sortieren 13

• bisher: nur Sortieren von Strings• Es gibt aber oft andere Typen zu sortieren,

z.B. Integer-, Double-, Struct-Typen usw. Generischer Sortieralgorithmus für Felder• Sortieralgorithmen identisch bis auf

– Vergleichsfunktion comp()– Austauschfunktion swap()

Generische Funktionsparameter Funktionen als Parameter


Sortieren 14

• Generische Funktionsparameter Nutzung des Typs void• Beispiel: swap-Funktion void swapv(void *s[], int i, int j){ void *t;

t = s[i]; s[i] = s[j]; s[j] = t;}


Sortieren 15

• Funktionen als Parameter• C erlaubt, Funktionen als Parameter an

Funktionen zu übergeben und aufzurufen• Übergabe der Funktion comp()void bsortv(void *v[], int n, int (*comp)(void *, void *)){ ...

• Aufruf der Funktion comp() ... if((* comp)(v[j], v[j+1]) > 0) ...


Sortieren 16

• Bubblesort generisch


Sortieren 17

• Quicksort generisch


Sortieren 18

• sortlib – snumcmp()


Sortieren 19

• sortlib – sswapv()


Sortieren 20

• bsort5


Sortieren 21

• qsort5


Sortieren 22

• Mit generischen Funktionen und Funktionen als Parametern auch Sortieren von komplexeren Datenstrukturen möglich

• Beispiel: Personaldatentypedef struct _person { /* Personaleintrag: */ int no; /* Personalnummer */ char *nn; /* Nachname */ char *vn; /* Vorname */ int gj; /* Geburtsjahr */ int gm; /* Geburtsmonat */ int gt; /* Geburtstag */} person_t, *person_p;


Sortieren 23

• Personalliste nach verschiedenen Kriterien (Name, P-Nr., Geburtsdatum) sortierbar

Implementierung einer Vergleichsfunktion• Beispiel: Nachnamen vergleichen

int compnn(person_p p1, person_p p2){ int n; if(n = strcmp(p1->nn, p2->nn)) return(n); else return(strcmp(p1->vn, p2->vn));}


Sortieren 24

• personal.c


Suchen 1

• Häufige Aufgabe: in größeren Datenmengen nach Einzelelementen suchen

• Oft: Daten in Feldern gespeichert• Intuitives Verfahren: Feld mit Daten von

Anfang bis Ende durchlaufen und nach gesuchtem Element fahnden– ist bei großen Datenmengen sehr langsam– notwendig bei unsortierten Daten / Feldern

in sortierten Feldern mit binärer Suche arbeiten


Suchen 2

• Beispiel: Suche in Integer-Feld


Suchen 3

• Binäre Suche: teile und finde


Suchen 4

• 1 Schritt: teilen und vergleichen


Suchen 5

• 2. Schritt: weiter teilen und vergleichen


Suchen 6

• 3. Schritt: weiter teilen und vergleichen


Suchen 7

• 4. Schritt: teilen und finden


Suchen 8

• Binärsuche: teilen und finden


Suchen 9

int binsearchi(int v[], int n, int x, int *ind)int m, l, r; /* Mitte, links, rechts */l = 0; /* links: 1. Element */r = n - 1; /* rechts: letztes El. */while(1) { if(r < l) return(0); /* kein Treffer */ m = l + ((r - l) / 2); /* Bereich halbieren */ if (v[m] == x) { /* Elem. x gefunden */ *ind = m; return(1); } if (v[m] > x) r = m - 1; /* Rechts weiter */ else l = m + 1; /* Links weiters */}


Suchen 10

• binsearchi.c - Binärsuche in int-Feld


Suchen 11

• binsearchs.c - Binärsuche in String-Feld


Dynamische Listen 1

• Häufig ist die Anzahl der zu speichernden und zu bearbeitenden Daten erst zur Laufzeit des Programms bekannt

• Felder ungeeignet, da diese zur Compilezeit dimensioniert werden müssen

dynamische Datenstrukturen– einfach verkettete Listen– doppelt verkettete Listen – Bäume– usw.


Dynamische Listen 2

• Beispiel: einfach verkettete Liste/* Datentyp f. einfach verkettete Liste */ typedef struct _slist { int value; /* Daten */ struct slist *next; /* Nachfolger */} slist;

• Beispiel: doppelt verkette Liste/* Datentyp f. doppelt verkettete Liste */typedef struct _dlist { int value; /* Daten */ struct dlist *prev; /* Vorgaenger */ struct dlist *next; /* Nachfolger */} dlist;


Dynamische Listen 3

• Objekte der Listentypen werden zur Laufzeit – alloziertslist *insert(slist *llp, int value){ slist *nlp; nlp = (slist *) malloc(sizeof(slist));

– besetzt bzw. initialisiert nlp-> value = value; nlp->next = NULL;

– und in die Liste eingehängt if(llp) llp->next = nlp; return(nlp);}


Dynamische Listen 4

• Einfache Liste: Erzeugung 1. Element


Dynamische Listen 5

• Einfache Liste: 2. Element und Verkettung


Dynamische Listen 6



Dynamische Listen 7



Dynamische Listen 8



Dynamische Listen 9

• Einfache Liste: Verkettung zum Ringpuffer


Dynamische Listen 10

• Erstes Element wird oft Wurzel, Anker oder Kopf der Liste genannt

• Durchlaufen der Liste i.d.R. von der Wurzel der Liste ausslist *root, *slp;for(slp = root; slp; slp = slp->next) printf("%d\n", slp->value);

• Wird das letzte Listenobjekt mit der Wurzel verlinkt Ringpuffer

• Sortieren bei Erzeugen der Liste möglich



• slist.c - einfach verkettete Liste



• sortlist.c - einfach verkettete sortierte Liste



• Doppelte Liste: Erzeugung 1. Element



• Doppelte Liste: 2. Element und Verkettung



• Doppelte Liste: Verkettung zum Ringpuffer



• dlist1.c - doppelt verkettete Liste



• dlist2.c - doppelt verk. Liste als Ringpuffer



• Binäre Bäume



• wordcount.c - sortierter binärer Baum

Informatik II Grundlagen der Programmierung Programmieren in C Module und Bibliotheken 3 Hochschule...

Documents

Transcript of Informatik II Grundlagen der Programmierung Programmieren in C Module und Bibliotheken 3 Hochschule...