Präsentation herunterladen
Die Präsentation wird geladen. Bitte warten
1
AlgoDat Fragen zu Vorlesung und Klausur
Hochschule Fulda – FB AI Sommersemester 2016 Peter Klingebiel, HS Fulda, AI
2
Vorab: Was ist wichtig? AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
3
Vorab: Was ist wichtig? AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
4
ALLES ! Vorab: Was ist wichtig?
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
5
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
6
Fragen zu Vorlesung / Klausur
Komplexität von Algorithmen (O-Funktionen) Listen (Felder und Bäume) Pointer und Pointersyntax Sortieren Bitoperationen und Bitfelder AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
7
Fragen zu Vorlesung / Klausur
Komplexität von Algorithmen (O-Funktionen) Listen (Felder und Bäume) Pointer und Pointersyntax Sortieren Bitoperationen und Bitfelder AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
8
Komplexität von Algorithmen 1
Wichtige Anforderungen an Algorithmen Laufzeiteffizienz Speichereffizienz Beispiel: Iteration vs. Rekursion? Beispiel: Sortieren in-place? sehr schwer abzuschätzen nur Näherungen möglich! Modell eines einfachen Rechners Definition von elementaren Operationen AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
9
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
10
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
11
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 n0 gibt, so dass gilt: f(n) ≤ c g(n) für n ≥ n0 d.h. für alle n ≥ n0 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
12
O-Notation 3 Beispiele: 2n + 10 = O(n) Wachstum linear
n2 ≠ O(n) Wachstum quadratisch, nicht linear 5n3 + 12n = O(n3) 4 log2 n + 9 = O(log2 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
13
O-Notation 4 O-Notation definiert Komplexitätsklassen
O(1) konstant O(n) linear O(n2) quadratisch O(logn) logarithmisch O(en) exponentiell Bestimmung der Größenordnung einfache for-Schleife n·O(1) = O(n) geschachtelte for-Schleife n·n·O(1) = O(n2) erst einfache for-Schleife, danach geschachtelte for-Schleife O(n + n2) = O(n2) Binäre Suche O(log2 n) AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
14
Fragen zu Vorlesung / Klausur
Komplexität von Algorithmen (O-Funktionen) Listen (Felder und Bäume) Pointer und Pointersyntax Sortieren Bitoperationen und Bitfelder AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
15
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
16
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
17
Dynamische Listen 3 Einfache Liste: Erzeugung 1. Element
Programmieren in C - Peter Klingebiel - HS Fulda - DVZ
18
Dynamische Listen 4 Einfache Liste: 2. Element und Verkettung
Programmieren in C - Peter Klingebiel - HS Fulda - DVZ
19
Dynamische Listen 5 Einfache Liste: 3. Element und Verkettung
Programmieren in C - Peter Klingebiel - HS Fulda - DVZ
20
Dynamische Listen 6 Einfache Liste: 4. Element und Verkettung
Programmieren in C - Peter Klingebiel - HS Fulda - DVZ
21
Dynamische Listen 7 Einfache Liste: 5. Element und Verkettung
Programmieren in C - Peter Klingebiel - HS Fulda - DVZ
22
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
23
Dynamische Listen 9 Doppelte Liste: Erzeugung 1. Element
Programmieren in C - Peter Klingebiel - HS Fulda - DVZ
24
Dynamische Listen 10 Doppelte Liste: 2. Element und Verkettung
Programmieren in C - Peter Klingebiel - HS Fulda - DVZ
25
Dynamische Listen 11 Doppelte Liste: 3. Element und Verkettung
Programmieren in C - Peter Klingebiel - HS Fulda - DVZ
26
Dynamische Listen 12 Doppelte Liste: 4. Element und Verkettung
Programmieren in C - Peter Klingebiel - HS Fulda - DVZ
27
Binärbäume Binäre Bäume
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
28
Fragen zu Vorlesung / Klausur
Komplexität von Algorithmen (O-Funktionen) Listen (Felder und Bäume) Pointer und Pointersyntax Sortieren Bitoperationen und Bitfelder AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
29
Adressen und Pointer 1 Speicherplatz von a, b,c Orte im Speicher
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
30
Adressen und Pointer 2 Zuweisung a=4; Wert an Speicherstelle
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
31
Adressen und Pointer 3 Programmstart und Aufruf von main()
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
32
Adressen und Pointer 4 Zuweisung i = 5;
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
33
Adressen und Pointer 5 Zuweisung ip = &i;
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
34
Adressen und Pointer 6 Berechnung *ip + *ip;
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
35
Pointer und Pointersyntax
Beispiel: einfache Pointersyntax int var = 11; int sum; int *varptr = &var; // varptr -> var *varptr += 4; // um 4 erhoehen sum = var + *varptr; // sum ? // sum = = 30; Beispiel: Struct mit Pointer 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
36
Fragen zu Vorlesung / Klausur
Komplexität von Algorithmen (O-Funktionen) Listen (Felder und Bäume) Pointer und Pointersyntax Sortieren Bitoperationen und Bitfelder AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
37
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
38
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
39
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
40
Vergleich der Sortieralgorithmen
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
41
Fragen zu Vorlesung / Klausur
Komplexität von Algorithmen (O-Funktionen) Listen (Felder und Bäume) Pointer und Pointersyntax Sortieren Bitoperationen und Bitfelder AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
42
Zahlendarstellung Integerzahlen
Dezimal-, Sedezimal-, Binärdarstellung AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
43
Logische Operatoren ! && ||
Logische Operationen Logische Operatoren ! && || Ergebnis: wahr 1, falsch 0 (Typ int) expr1 op expr2 AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
44
Bitoperationen 1 Bitoperatoren ~ & | ^ expr1 op expr2 bzw. ~expr
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
45
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
46
Bitfelder 1 Zugriff auf Variable: kleinste Einheit Byte
Wenn Zugriff auf einzelne Bits (oder Gruppen von Bits) erforderlich bitfield Bitfeld: Sonderform des Struct mit Angabe der Bitanzahl je Element Beispiel 8 Bit-IO-Register: typedef struct _register { int ready: 1; // geraet bereit int read: 1; // geraet auf eingabe int write: 1; // geraet auf ausgabe int dummy: 1; // nicht benutzt int data: 4: // 4 datenbits fuer io } register_t; AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
47
Bitfelder 2 Beispiele für Zugriffe: // register definieren register_t reg; // io register int data; // datenwert // register auf eingabe stellen und lesen reg.write = 0; reg.read = 1; if(reg.ready) // lesen, wenn bereit data = reg.data; // register auf ausgabe stellen und schreiben reg.read = 0; reg.write = 1; if(reg.ready) reg.data = data; AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
48
… und nun: viel Erfolg in der Klausur …
AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI
Ähnliche Präsentationen
© 2024 SlidePlayer.org Inc.
All rights reserved.