AlgoDat Fragen zu Vorlesung und Klausur

Transkript

1 AlgoDat Fragen zu Vorlesung und Klausur Hochschule Fulda FB AI Sommersemester Peter Klingebiel, HS Fulda, AI

2 Vorab: Was ist wichtig? AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 2

3 Vorab: Was ist wichtig? ALLES! AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 3

4 Der Alles-Markierer von Pia Valentin (AI - Digitale Medien Danke an Pia für das Foto) 1. Platz im Fotowettbewerb Zeig mir wie Du lernst, HS Fulda 2014 AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 4

5 Fragen zu Vorlesung / Klausur Komplexität von Algorithmen (O-Funktionen) Listen (Felder und Bäume) Pointer und Pointersyntax Sortieren Bitoperationen AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 5

7 Komplexität von Algorithmen 1 Wichtige Anforderungen an Algorithmen Laufzeiteffizienz Speichereffizienz Speichereffizienz Beispiel: Iteration vs. Rekursion? Beispiel: Sortieren in-place? Laufzeiteffizienz sehr schwer abzuschätzen nur Näherungen möglich! Modell eines einfachen Rechners Definition von elementaren Operationen AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 7

8 Komplexität von Algorithmen 2 Beispiele für Elementaroperationen Wert zuweisen, Zugriff auf Variable Arithmetische Operation / Logische Operation Zugriff auf Feldelement per Index Pointerzugriff bzw. derefenzierung Aufruf einer Funktion / Rückkehr aus Funktion Elementaroperationen zählen liefert die Laufzeit des Algorithmus in Abhängigkeit der Menge der Eingabedaten Beispiel: Lineare Suche in Feld der Größe n AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 8

9 O-Notation 1 Berechnung der Laufzeit von Algorithmen ist sehr komplex, da sie von vielen Faktoren abhängig ist! Dennoch sind Aussagen zur Laufzeit eines Algorithmus sinnvoll und notwendig Zur Laufzeitabschätzung Beschränkung auf Rechnen in Größenordnungen Frage: Wie verändert sich die Laufzeit eines Algorithmus, wenn die Menge der Eingabedaten vergrößert wird? AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 9

10 O-Notation 2 Dabei werden konstante Faktoren und kleinere Beiträge zur Laufzeit vernachlässigt O-Notation hilft obere Schranken für die Wachstumrate der Laufzeit eines Algorithmus zu finden Definition gegeben: zwei Funktionen f(n) und g(n) f(n) wächst asymptotisch nicht schneller als g(n), wenn es eine Konstante c > 0 und eine Zahl n 0 gibt, so dass gilt: f(n) c g(n) für n n 0 d.h. für alle n n 0 ist f(n) nicht wesentlich größer als g(n) man sagt auch: f(n) ist O(g(n)) AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 10

11 O-Notation 3 Beispiele: 2n + 10 = O(n) Wachstum linear n 2 O(n) Wachstum quadratisch, nicht linear 5n n = O(n 3 ) 4 log 2 n + 9 = O(log 2 n) O-Notation gibt obere Schranken für die Wachstumrate einer Funktion an O-Notation klassifiziert Funktionen gemäß ihres Wachstums vernachlässigt dabei kleine Problemgrößen, konstante Faktoren und Terme niedriger Ordnung AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 11

12 O-Notation 4 O-Notation definiert Komplexitätsklassen O(1) konstant O(n) linear O(n 2 ) quadratisch O(log n ) logarithmisch O(e n ) exponentiell Bestimmung der Größenordnung einfache for-schleife n O(1) = O(n) geschachtelte for-schleife n n O(1) = O(n 2 ) erst einfache for-schleife, danach geschachtelte for-schleife O(n + n 2 ) = O(n 2 ) Binäre Suche O(log 2 n) AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 12

14 Dynamische Listen 1 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; Programmieren in C - Peter Klingebiel - HS Fulda - DVZ 14

15 Dynamische Listen 2 Objekte der Listentypen werden zur Laufzeit alloziert slist *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); } Programmieren in C - Peter Klingebiel - HS Fulda - DVZ 15

16 Dynamische Listen 3 Einfache Liste: Erzeugung 1. Element Programmieren in C - Peter Klingebiel - HS Fulda - DVZ 16

17 Dynamische Listen 4 Einfache Liste: 2. Element und Verkettung Programmieren in C - Peter Klingebiel - HS Fulda - DVZ 17

21 Dynamische Listen 8 Erstes Element wird oft Wurzel, Anker oder Kopf der Liste genannt Durchlaufen der Liste i.d.r. von der Wurzel der Liste aus slist *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 Programmieren in C - Peter Klingebiel - HS Fulda - DVZ 21

22 Dynamische Listen 9 Doppelte Liste: Erzeugung 1. Element Programmieren in C - Peter Klingebiel - HS Fulda - DVZ 22

23 Dynamische Listen 10 Doppelte Liste: 2. Element und Verkettung Programmieren in C - Peter Klingebiel - HS Fulda - DVZ 23

26 Binärbäume Binäre Bäume AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 26

28 Adressen und Pointer 1 Speicherplatz von a, b,c Orte im Speicher AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 28

29 Adressen und Pointer 2 Zuweisung a=4; Wert an Speicherstelle AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 29

30 Adressen und Pointer 3 Programmstart und Aufruf von main() AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 30

31 Adressen und Pointer 4 Zuweisung i = 5; AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 31

32 Adressen und Pointer 5 Zuweisung ip = &i; AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 32

33 Adressen und Pointer 6 Berechnung *ip + *ip; AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 33

34 Pointer und Pointersyntax Beispiel: einfache Pointersyntax int var = 11; int sum; int *varptr = &var; *varptr += 4; sum = var + *varptr; // sum? // sum = = 30; Beispiel: Struct mit Pointer // varptr -> var // um 4 erhoehen struct _list { // einfache Liste int value; // wert struct _list *next; // Ptr auf nächstes Elem. } struct _list *root, *lptr; lptr = root->next; root->next->next == lptr->next; AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 34

36 Insertion Sort Algorithmus und C-Code // insertionsort von Feld ia mit n Elementen void isort(int a[], int n) { int i, j, t; // Lauf- und Tempvariable } for(i = 1; i < n; i++) { j = i; while(j > 0 && a[j] < a[j-1]) { t = a[j]; a[j] = a[j-1]; a[j-1] = t; --j; } } AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 36

37 Bubble Sort Algorithmus und C-Code // bubblesort von Feld ia mit n Elementen void bsort(int a[], int n) { int i, j, t; for(i = 0 ; i < n; i++) { for(j = 0 ; j < n-i-1; j++) { if(a[j] > a[j+1]) { t = a[j]; a[j] = a[j+1]; a[j+1] = t; } } } } AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 37

38 Quick Sort Algorithmus und C-Code //quicksortsort von Feld ia mit n Elementen void qsort(int a[], int l, int r) { int pivot = a[(l+r)/2], i = l, j = r, t; while(i <= j) { while(a[i] < pivot) i++; while(a[j] > pivot) j--; if(i <= j) { t = a[i]; a[i] = a[j]; a[j] = t; i++; j--; } } if(l < j) qsort(a, l, j); if(r > i) qsort(a, i, r); } AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 38

39 Vergleich der Sortieralgorithmen AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 39

41 Zahlendarstellung Integerzahlen Dezimal-, Sedezimal-, Binärdarstellung AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 41

42 Logische Operationen Logische Operatoren! && Ergebnis: wahr 1, falsch 0 (Typ int) expr1 op expr2 int a = 3, b = 8, c = 5; (a < b) && (c < b) (a == b) (c >= a) AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 42

43 Bitoperationen 1 Bitoperatoren ~ & ^ expr1 op expr2 bzw. ~expr AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 43

44 Bitoperationen 2 Bitshiftoperatoren << >> expr1 op expr2 Bits in expr1 um expr2 Bits verschoben Bsp. 1 << 2 1 um 2 Bits nach links Bsp: n >> 5 n um 5 Bits nach rechts AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 44

45 und nun: viel Erfolg in der Klausur AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI 45