AlgoDat Fragen zu Vorlesung und Klausur Hochschule Fulda – FB AI Sommersemester 2016 http://ad.rz.hs-fulda.de Peter Klingebiel, HS Fulda, AI

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

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

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

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

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

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

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

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

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

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

O-Notation 3 Beispiele: 2n + 10 = O(n)  Wachstum linear n2 ≠ O(n)  Wachstum quadratisch, nicht linear 5n3 + 12n2 + 17 = 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

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

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

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

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

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

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

Dynamische Listen 5 Einfache Liste: 3. Element und Verkettung Programmieren in C - Peter Klingebiel - HS Fulda - DVZ

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

Dynamische Listen 7 Einfache Liste: 5. Element und Verkettung Programmieren in C - Peter Klingebiel - HS Fulda - DVZ

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

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

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

Dynamische Listen 11 Doppelte Liste: 3. Element und Verkettung Programmieren in C - Peter Klingebiel - HS Fulda - DVZ

Dynamische Listen 12 Doppelte Liste: 4. Element und Verkettung Programmieren in C - Peter Klingebiel - HS Fulda - DVZ

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

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

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

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

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

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

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

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

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 = 15 + 15 = 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

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

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

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

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

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

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

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

Logische Operatoren ! && || Logische Operationen Logische Operatoren ! && || Ergebnis: wahr  1, falsch  0 (Typ int) expr1 op expr2 AlgoDat - Fragen - Peter Klingebiel - HS Fulda - AI

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

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

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

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

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