Algorithmen und Datenstrukturen Übungsmodul 1 Dr. W. Narzt u. Dr. A.Stritzinger Institut für Wirtschaftsinformatik- Software Engineering JKU Linz

Überblick Algorithmen allgemein Darstellungsarten Algorithmenbeschreibungssprache Jana Beispiele Übungsvorbesprechung Übung 1 Präsentation von 2 Übungen; bei der Präsentation kann der Quelltext von mir am Beamer dargestellt werden. Musterlösung oder eine Übung muß verfügbar sein, um Laborbetrieb zu gewährleisten

Algorithmen vs. Programme Problemlösungsverfahren, die sich aus einzelnen "Aktionen" zusammensetzen. Jede Aktion hat einen Effekt Jede Aktion -> eindeutig interpretierbar, ausführbar Algorithmus: statisch endlich 0..n Eingangsobjekte 0..n Ausgangs- oder Ergebnisobjekte 0..n lokale Hilfsobjekte Programme Programme sind Algorithmen, die in einer Programmiersprache abgefaßt sind, damit sie auf einem Rechner ausgeführt werden können Prozessor: Mensch oder Maschine User: integer erwartet, String eingegeben Device: Hardware Fehler: Printer ausgeschaltet, Festplatte defekt, Web-page kurzfristig nicht erreichbar Physical: Disk full, Mem full Code errors: Eine Methode wird inkorrekt ausgeführt, ungültiger Array index

JANA Übersicht Algorithmen (Prozeduren) Kommentare Operatoren Ablaufsteuerung (Sequenz, Selektion, Iteration) if / else if / else, switch; while, repeat, for 4 Elementare Datentypen boolean, int, float, char Felder (inkl. Zeichenketten) boolean[1:n], char[], float[-3:3], int[1:n; 1:m] und weitere Sprachkonstrukte Dies paßt auch zur Objektorientierung; Diskussion des Beispiels, Zeit lassen Welcher Code wird ausgeführt, Abarbeitung bis i =

JANA (2) Algorithmen (Prozeduren/Funktionen) int search ( int[1:n] values,  int x) { …} replace( int[1:n] values,  int valueToReplace,  int value) { …} Operatoren und Anweisungen Zuweisung: i = 1 // sprich i wird/becomes 1 Gleichheitsprüfung: i == 1 (Ergebnis: boolean) (auch: !=, <, >, >=, <=, *, /, %, +, -, !, &&, ||, usw.) i = search( values,  3) // Funktionsaufruf replace( values,  1,  4) // Prozeduraufruf // + Anweisungen zur Ablaufsteuerung

Ablaufsteuerung Verzweigung (Selektion) switch (ausdruck) { case ausdruck1: { Anweisungen1 } case ausdruck2: { Anweisungen2 } ... default: { Anweisungenn } } if (ausdruck) { Anweisungen } if (ausdruck1) { Anweisungen1 } else if (ausdruck2) { Anweisungen2 } else { Anweisungen3 }

Ablaufsteuerung (2) Schleifen (Iteration) // iteriert von i=1 bis n for (i=1 .. n) { Anweisungen } // i nimmt nacheinander alle // werte der menge  an for (i  ) { Anweisungen } // iteriert über 2er-potenzen for (int i=2, 4, 8, 16, .., n) { Anweisungen } while (ausdruck) { Anweisungen } repeat { Anweisungen } until (ausdruck)

Elementare Datentypen Elementare Typen: int ..., -1, 0, 1, 2, ... float ...-17.3, 0.0, 37788.6578887... char 'a', 'b', 'c', ... boolean true, false Konstanten: final int i = 5 final boolean a = true, b = false

Felder (Arrays) Annordnung einer Zahl von Elementen die fortlaufend nummeriert sind (Index von unterer bis oberer Grenze, muß ganze Zahl sein)   Deklaration in Jana: int[1:n] feld Feldliteral in Jana: feld = {1, 2, 3, 4} Elementzugriff erfolgt immer durch Indizierung: feld[i] = element element = feld[i] Alle Elemente müssen gleichen (statischen) Datentyp haben. Unterer und oberer Grenzindex sind frei wählbar. Für unteren Grenzindex ist 0 (Java, C++) oder 1 (Smalltalk) üblich. 17 33 7 21 1 2 3 4 .. n 12 13 14 Erstes Element an Position unterer Grenzindex (z.B.: 0) Letztes Element an Position oberer Grenzindex (z.B.: n) Index Elemente

Lineares Suchen in Feldern Gegeben ist ein unsortiertes Feld mit beliebigen ganzen Zahlen Gesucht: Ist eine bestimmte Zahl enthalten und an welcher Stelle?   //liefert die indexposition der gesuchten Zahl value in feld array, oder -1 //falls nicht enthalten int sequentialSearch(int[1:n] array, int value) { int index for (index = 1 to n) { if (array[index] == value) { // value an der Stelle index gefunden return index } // value im ganzen feld nicht enthalten return -1 Aufruf: position = sequentialSearch( myArray,  searchNumber)

Löschen und Einfügen in Felder Beim Löschen eines Feldelements müssen die dahinterliegenden Elemente um eine Stelle nach vor gereiht werden; deleteElem(float[1:n] array, int elemIndex) { int i if (elemIndex<1 or elemIndex>n) return; //ungültiger Index for (i = elemIndex to n-1) { array[i] = array[i+1] } Beim Einfügen müssen alle Elemente ab der Einfüge-Position nach hinten gereiht werden. Vorsicht: oberer Grenzindex, letztes Element geht verloren insertElem(float[1:n] array, int elemIndex, float value) { int i if (elemIndex<1 or elemIndex>n) return //ungültiger Index for (i=n-1 downto elemIndex) { array[i+1] = array[i] } array[elemIndex] = value;

Benutzerdefinierte Datentypen (Verbunde) 1 Neben den elementaren Typen sind auch benutzerdefinierte Datentypen erlaubt. Diese werden mit dem Schlüsselwort type gekennzeichnet. Typdefinitionen sind z.b.: type Person= { // verbundtyp int id char[1:n] lastName, firstName } type Day= (Mo,Tu,We,Th,Fr,Sa, Su) // aufzählungstyp type Matrix= int[7, 3] // matrix mit // grenzen 0..6 // und 0..2 type Month= (1..12) // Bereichstyp

Benutzerdefinierte Datentypen (Verbunde) 2 Typdeklaration: type Person { char[1:n] first, last } type Point { int x,y Variablen: Person a // Person a sind unmittelbar definiert, Speicherplatz ist reserviert a.first = "Max" // Zuweisung sofort möglich a.last = "Mustermann" Point p1; p1.x = 5 p1.y = 8 Variablendeklaration, Zuweisung, Vergleich, et.c. ähnlich primitiver Variable

Benutzerdefinierte Datentypen (Verbunde) 3 Verwendung als Eingangsparameter: f(Person p) { p.firstName = "nix" } Gesamte Person p wird kopiert. Änderungen haben somit keine Außenwirksamkeit. Verwendung als Übergangsparameter: f(Person p) { Person a a.firstName = “Franz" a.lastName = "Huber" p = a // keine Kopie, direkte Manipulation von p, außenwirksam

Felder von Verbunden Variablendeklaration: Verwendung: type Person { char[1:n] first, last } Person [n] pers //Array ist deklariert und definiert //Index 0..n-1 Person [1:n] pers2 //Array ist deklariert und definiert //Index 1..n Verwendung: pers[1].first = "Max" pers[1].last = "Mustermann" pers[2] = pers[1] //Alle Werte werden kopiert. if(pers[1] == pers[2]) // true, Wertvergleich pers2 = pers //pers2 muß gleich groß oder größer sein. // die einzelnen Datenwerte werden kopiert pers == pers2 (bedeutet: alle Werte aller Datenobjekte sind gleich -> Felder gleich groß)

Zusammengesetzte Verbunde Typdeklaration: type Point { int x,y } type Rectangle { Point p int width, height Verwendung: Rectangle r1, r2; // r ist mit allen inneren Verbunden definiert r1.p.x = 5 r1.p.y = 10 r1.width = 100 r1.height = 50 r2 = r1 // kopiert alle (inkl. innerer) Werte if (r2 == r1) // alle Werte werden verglichen -> true

Zusammenfassung Algorithmen (Prozeduren) Kommentare Operatoren Rückblick Algorithmen (Prozeduren) Kommentare Operatoren Ablaufsteuerung (Sequenz, Selektion, Iteration) if / else if / else, switch; while, repeat, for 4 Elementare Datentypen boolean, int, float, char Felder (inkl. Zeichenketten) boolean[1:n], char[], float[-3:3], int[1:n; 1:m] und weitere Sprachkonstrukte Dies paßt auch zur Objektorientierung; Diskussion des Beispiels, Zeit lassen Welcher Code wird ausgeführt, Abarbeitung bis i =

Beispiel: Sinusberechnung durch Reihenentwicklung Idee: Sinusfunktion kann durch folgende Reihe beliebig genau angenähert werden: sin (x) = x1/1! - x3/3! + x5/5! - x7/7! + x9/9! - ...   Zusatzidee: Wenn der Wert eines Terms kleiner ist als maximal zulässiger Fehler, dann ist die Abweichung des Näherungswertes vom exakten Sinuswert auch kleiner als der maximal zulässige Fehler und dahinterliegende Terme können ignoriert werden (konvergierende Reihe). Sinus - Version 1: float sinus (↓float angle) { i = 1 ergebnis = term(i) while (ergebnis noch zu ungenau) { i = i+1 //berechne nächsten term(i) ergebnis = ergebnis +/- term(i) } return ergebnis

Beispiel: Sinusberechnung durch Reihenentwicklung (2) float sinus (↓float angle) { int i int termVorzeichen float term, ergebnis, maximalerFehler maximalerFehler = 10-7 // 0.0000001 i = 1 termVorzeichen = -1 term = angle ergebnis = angle //while (ergebnis noch zu ungenau) { while (|term| > maximalerFehler) { i = i+2 //!!! statt i+1 //berechne nächsten term(i) term = (anglei / i!) * termVorzeichen termVorzeichen = -termVorzeichen // schaltet Vorzeichen um ergebnis = ergebnis + term // akkumuliert terme in ergebnis } return ergebnis