Algorithmen und Datenstrukturen CS1017

Transkript

1 Algorithmen und Datenstrukturen CS1017 Th. Letschert TH Mittelhessen Gießen University of Applied Sciences Rekursiv definierte Strukturen und strukturelle Rekursion Listen und Bäume Strukturelle Rekursion und Induktion Implementierung rekursiv definierter Strukturen: null / Optional Imperative Datenstrukturen

2 Datenstrukturen Datenstrukturen Datenstruktur Eine Datenstruktur ist eine Struktur (Anordnung von Dingen), deren Elemente Daten sind Beispiel Array: Ein Array besteht aus Daten die hintereinander angeordnet sind Datenstrukturen in Java Java bietet drei Mittel zur Strukturierung von Daten Array: Daten gleicher Art zusammenfassen und mit Index zugreifen Objekt: Daten unterschiedlicher Art zusammenfassen und mit Namen zugreifen Zeiger / Pointer: Bezug zu einer anderen Datenstruktur Bemerkung Datenstrukturen werden mit den Kern-Elementen einer Sprache konstruiert, alles was sich in der API findet, auch Ströme (java.util.stream), sind keine Datenstrukturen sondern Datenabstraktionen Seite 2

3 Datenstrukturen Funktionale und imperative Datenstrukturen Funktionale Datenstruktur Eine funktionale Datenstruktur ist eine Struktur (Anordnung von Dingen), deren Elemente Werte sind Imperative Datenstrukturen Eine imperative Datenstruktur ist eine Struktur (Anordnung von Dingen), deren Elemente Variablen sind Beispiel Java Java ist eine imperative Sprache Datenstrukturen in Java sind darum prinzipiell strukturierte Variablen Der imperative Programmierstil hat in den letzten Jahren stark an Popularität verloren Imperative Sprache erlauben es Programme im funktionalen Stil zu schreiben Java unterstützt das funktionale Programmieren in einer imperativen Sprache durch einige (eher wenige) Bestandteile der API, z.b. Streams Seite 3

4 Rekursiv definierte Datenstrukturen Rekursion zur Definition von Daten Funktionen können rekursiv definiert werden Basis: Der Wert für einfache Fälle wird direkt angegeben Rekursion: Der Wert für komplexere Fälle wird aus dem Wert für einfachere Fälle berechnet Beispiel: fak(n) = 1 falls n = 0 fak(n) = fak(n-1)*n n > 0 Daten können rekursiv definiert werden Das Prinzip der Rekursion kann auch auf die Definition von Daten angewendet werden (Funktionale) Daten (-strukturen) können rekursiv definiert werden: Basis: Welche unstrukturierten Werte bilden eine (triviale) Struktur Rekursion: Wie wird eine Struktur aus gegeben Werten definiert Beispiel Liste Basis: Rekursion: Die leere Liste ist eine Liste Eine Liste kann aus einer gegeben Liste gebildet werden, indem man ein Element hinzunimmt Seite 4

5 Rekursiv definierte Datenstrukturen Rekursiv definierte Daten Beispiel vollständig geklammerte arithmetische Ausdrücke Basis: (Ganze) Zahl (als Zeichenkette) Konstruktionen: Ausdruck1, Ausdruck2 => '(' Ausdruck1 Leerzeichen Operator Leerzeichen Ausdruck2 ')' Es wird eine Menge von speziell strukturierten Zeichenketten definiert Beispiel arithmetische Ausdrucksbäume Basis: (Ganze) Zahl Konstruktionen: Ausdruck1, Ausdruck2 => op Ausdruck1 Ausdruck2 Es wird eine Menge von speziell strukturierten Bäumen definiert Seite 5

6 Rekursiv definierte Datenstrukturen Rekursiv definierte Daten Allgemeine Konstruktion Datenstrukturen können rekursiv definiert werden durch Angabe einer Menge von Basis-Elementen sowie Angabe einer Menge von Konstruktionsfunktionen Daten, Datenstrukturen, Datentypen Für rekursiv definierte Daten werden verschiedene Bezeichnungen verwendet Datentypen nennen sie viele, aber Vorsicht: der Begriff Datentyp hat in der Informatik noch eine andere wichtige Bedeutung Induktive Menge ist eine Bezeichnung die unter Mathematikern üblich ist Algebraischer Datentyp ist eine weitere übliche Bezeichnung Das Konzept ist so einfach, dass die meisten Bezeichnungen ein Komplexität vortäuschen, die nicht vorhanden ist Seite 6

7 Strukturelle Rekursion Rekursion auf rekursiven Daten Rekursiv definierte Funktionen auf rekursiv definierten Daten Rekursiv definierte Daten haben eine natürliche Zergliederung: Sie können in die Bestandteile zerlegt werden, aus denen sie gebildet wurden Berechnungen auf rekursiv definierten Daten können darum gut mit dem Prinzip Teile- / Reduziere-und-Herrsche (und so mit rekursiven Algorithmen) gelöst werden. Beispiel Rekursiv definierte Daten: Ausdrucksbäume Problem: Wertberechnung Lösung nach dem Prinzip Teile-und-Herrsche: op Wert Ausdruck1 = fop Wert Ausdruck2 Ausdruck1, Wert Seite 7 Ausdruck2

8 Strukturelle Rekursion Rekursion über die Struktur rekursiver Daten Strukturelle Rekursion Funktionen auf rekursiv definierten Daten d können durch Fallunterscheidung über die Art der Konstruktion von d definiert werden. Diese Art der Funktionsdefinition nennt man strukturelle Rekursion Seite 8

9 Strukturelle Induktion Strukturelle Induktion Vollständige Induktion Beweistechnik um Aussagen über natürliche Zahlen zu beweisen Jede natürliche Zahl ist dabei entweder 1 oder n+1 für irgendeine natürliche Zahl n Die natürlichen Zahlen werden hier offensichtlich als rekursiv definierte Daten aufgefasst Strukturelle Induktion Verallgemeinerung der Beweistechnik vollständige Induktion auf beliebige rekursiv definierte Daten Seite 9

10 Listen funktional Listen: rekursive Definition Eine Integer-Liste ist die leere Liste Nil oder wird mit der Cons-Operation aus einem Integer-Wert und einer Integer-Liste gebildet Bemerkung: Die Bezeichnungen Nil und Cons sind seit ca üblich OO-Implementierung Integer-Liste: oder : Ableitungsvarianten eines Interface' oder einer abstrakten Klasse und : Zusammenfassung in einer Klasse interface IntList { class Nil implements IntList { class Cons implements IntList { Cons(int head, IntList tail) { this.tail = tail; int IntList tail; Seite 10

11 Listen funktional Strukturelle Rekursion auf Listen Ein Problem auf Integer-Listen wird für die die leere Liste Nil gelöst oder wird bei einer mit der Cons-Operation gebildeten Liste gelöst indem es für die enthaltende (kürzere) Integer-Liste gelöst wird und mit dieser Teil-Lösung dann die Gesamt-Lösung gebildet wird Beispiel interface IntList { public class Integer_Lists { class Nil implements IntList { public static int length(intlist lst) { return (lst instanceof Nil)? 0 : 1 + length( ((Cons)lst).tail ); public static int sum(intlist lst) { if (lst instanceof Nil) { return 0; else { Cons cons = (Cons) lst; return cons.head + sum(cons.tail); class Cons implements IntList { Cons(int head, IntList tail) { this.tail = tail; int IntList tail; public class Integer_ListsTest public void test() { IntList lst = 1, 2, 3, new Nil()))); assertequals(0, length(new Nil())); assertequals(3, length(lst)); assertequals(0, sum(new Nil())); assertequals(6, sum(lst)); Seite 11

12 Bäume funktional Bäume: rekursive Definition Ein binärer Baum mit Integer-Werten ist ein Leaf mit einem Integer-Wert oder wird mit der Node-Operation aus einem Integer-Baum und einem Integer-Baum gebildet Bemerkung: Man kann Bäume auf diverse andere Arten definieren OO-Implementierung eines Integer-Baums: interface IntTree { class Leaf implements IntTree { Leaf(int value) { this.value = value; int value; class Node implements IntTree { Node(IntTree left, IntTree right) { this.left = left; this.right = right; IntTree left, right; Seite 12

13 Bäume funktional interface IntTree { Strukturelle Rekursion auf Bäumen class Leaf implements IntTree { Leaf(int value) { this.value = value; int value; Beispiel public class Int_Trees { class Node implements IntTree { Node(IntTree left, IntTree right) { this.left = left; this.right = right; IntTree left, right; public static int sum(inttree tree) { if (tree instanceof Leaf) { return ((Leaf)tree).value; else { Node node = (Node) tree; return sum(node.left) + sum(node.right); public class Int_TreesTest public void test() { IntTree t = new Node( new Node( new Leaf(1), new Leaf(2)), new Leaf(3)); assertequals(0, sum(new Leaf(0))); assertequals(6, sum(t)); Seite 13

14 Listen und Bäume generisch Strukturelle Rekursion auf generischen Listen Beispiel interface GenList<T> { class GenNil<T> implements GenList<T> { class GenCons<T> implements GenList<T> { GenCons(T head, GenList<T> tail) { this.tail = tail; T public class Generic_Lists { GenList<T> tail; public static <T> int length(genlist<t> lst) { return (lst instanceof GenNil)? 0 : 1 + length( ((GenCons<T>)lst).tail ); public static <T extends Comparable<T>> T maximum(genlist<t> lst) { if (lst instanceof GenNil) { throw new IllegalArgumentException("List must not be empty"); else { GenCons<T> cons = (GenCons<T>) lst; if (cons.tail instanceof GenNil) return cons. T maxtail = maximum(cons.tail); return cons.head.compareto(maxtail) > 0? cons.head : maxtail; Seite 14

15 Strukturelle Rekursion Implementierung der strukturellen Rekursion Variante 1: Mit Typ-Prüfung eine statische Methode die den Typ ihres Arguments prüft siehe Beispiele oben interface IntList { class Nil implements IntList { class Cons implements IntList { Cons(int head, IntList tail) { this.tail = tail; int IntList tail; static int length(intlist lst) { return (lst instanceof Nil)? 0 : 1 + length( ((Cons)lst).tail ); Variante 2: Mit Polymorphismus polymorphe Methoden pro Typ-Variante klassische OO-Programmierung interface IntList { int length(); class Nil implements IntList public int length() {return 0; class Cons implements IntList { Cons(int head, IntList tail) { this.tail = public int length() { return 1 + tail.length(); int IntList tail; Seite 15

16 Strukturelle Rekursion Sortieren von Listen Insertion Sort Kann als rekursive Funktion auf Listen definiert werden: public static <T extends Comparable<T>> GenList<T> sort(genlist<t> lst) { if (lst instanceof GenNil) { return lst; else { GenCons<T> cons = (GenCons<T>) lst; GenList<T> sortedtail = sort(cons.tail); return insert (cons.head, sortedtail); private static <T extends Comparable<T>> GenList<T> insert(t x, GenList<T> lst) { if (lst instanceof GenNil) { return new GenCons<>(x, new GenNil<T>()); else { GenCons<T> cons = (GenCons<T>) lst; if (x.compareto(cons.head) < 0) { return new GenCons<T>(x, lst); else return new GenCons<T>(cons.head, insert(x, cons.tail)); Seite 16

17 Implementierung rekursiv definierter Strukturen Zeiger / Pointer / Verweise Rekursiv Definierte Strukturen und Zeiger Rekursiv definierte Strukturen werden immer mit Hilfe von Zeigern implementiert. Die Komponenten gleicher Art sind in einer Struktur nicht direkt enthalten: es wird auf sie verwiesen Zeiger sind ein mächtiges Hilfsmittel mit dem man vieles machen kann vor allem vieles falsch In Java und vielen anderen Sprachen sind die Zeiger versteckt Sie können im Wesentlichen nur implizit und zum Verweis auf Unterstrukturen verwendet werden IntList lst = 1, 2, 3, new Nil() ) ) ); interface IntList { 1 class Nil implements IntList { class Cons implements IntList { Cons(int head, IntList tail) { this.tail = tail; int IntList tail; 2 3 Seite 17

18 Implementierung rekursiv definierter Strukturen Zeiger-Arithmetik Manipulation von Zeiger-Variablen Variablen, deren Wert Zeiger sind, können auch in Java direkt verändert werden Man spricht dann von Rechnen mit Zeigern oder auch von Pointer-Arithmetik Beispiel: Summe einer Liste public static int sump(intlist lst) { int sum = 0; for (IntList p = lst;!(p instanceof Nil); sum = sum + ((Cons)p). return sum; p = ((Cons)p).tail) { p IntList lst = interface IntList { lst 1, class Nil implements IntList { 1 class Cons implements IntList { Cons(int head, IntList tail) { this.tail = tail; int IntList tail; 2 2, 3, 3 new Nil() ) ) ); Seite 18

19 Implementierung rekursiv definierter Strukturen Zeiger-Arithmetik null-zeiger statt leerem Objekt der null-zeiger, der leere Zeiger kann als Ersatz einer leeren Struktur verwendet werden. Damit wird die Darstellung und Verarbeitung effizienter diese Stil des Programmieren gilt als unsicher und wird nicht mehr empfohlen aber noch extrem oft verwendet leer! Kann durch null ersetzt werden. interface IntList { class Nil implements IntList { class Cons implements IntList { Cons(int head, IntList tail) { this.tail = tail; int IntList tail; class Cons { Cons(int head, Cons tail) { this.tail = tail; int Cons tail; Seite 19

20 Implementierung rekursiv definierter Strukturen Zeiger-Arithmetik null-zeiger statt leerem Objekt Beispiel: class Cons { Cons(int head, Cons tail) { this.tail = tail; int Cons tail; public static int sum(cons lst) { int sum = 0; for (Cons p = lst; p!= null; p = p.tail) { sum = sum + p. return sum; Cons lst = 1, 2, 3, null ) ) ); System.out.println(sum(lst)); Seite 20

21 Implementierung rekursiv definierter Strukturen Optional Typ Optional statt Zeiger die eventuell null sind Der null-zeiger zur Repräsentation von Objekten, die leer / nicht da sind, wird heute generell nicht mehr empfohlen Statt dessen: Typ / Interface Optional Repräsentierte optionale Objekte (da oder nicht da) Beispiel: import java.util.optional; class Cons { Cons(int head, Cons tail) { this.tail = Optional.of(tail); Cons(int head) { this.tail = Optional.empty(); int Optional<Cons> tail; public static int sum(optional<cons> lst) { int sum = 0; for (Optional<Cons> p = lst; p.ispresent(); sum = sum + p.get(). return sum; Optional<Cons> lst = Optional.of( 1, 2, 3 ) ) )); System.out.println(sum(lst)); Seite 21 p = p.get().tail) {

22 Imperative Strukturen Imperative Datenstrukturen Funktionale und imperative Datenstrukturen Eine funktionale Datenstruktur ist eine Struktur (Anordnung von Dingen), deren Elemente Werte sind Diese Art von Datenstruktur haben wir bisher betrachtet Eine imperative Datenstruktur ist eine Struktur (Anordnung von Dingen), deren Elemente Variablen sind Imperative Datenstrukturen sind veränderlich Seite 22

23 Imperative Strukturen Imperative Datenstrukturen Beispiel: imperative Liste class List { private class Node { Node(int head, Optional<Node> tail) { this.tail = tail; int Optional<Node> tail; Die imperative Variante der Liste erfordert eine Kapselung der Datenstruktur in einer Hüllklasse. Optional<Node> anchor = Optional.empty(); void cons(int x) { anchor = Optional.of(new Node(x, anchor)); int sum() { int sum = 0; for (Optional<Node> p = anchor; p.ispresent(); sum = sum + p.get(). return sum; p = p.get().tail) { List lst = new List(); lst.cons(3); lst.cons(2); lst.cons(1); System.out.println(lst.sum()); Seite 23