HEUTE. Datenstrukturen im Computer. Datenstrukturen. Rekursion. Feedback Evaluation. abstrakte Datenstrukturen

Transkript

1 9.2.5 HUT atenstrukturen im omputer atenstrukturen ie beiden fundamentalen atenstrukturen in der Praxis sind rray und Liste Rekursion Feedback valuation rray Zugriff: schnell Umordnung: langsam Liste Zugriff: langsam Umordnung: schnell abstrakte atenstrukturen atenstrukturen im omputer atenstrukturen sind Verwaltungseinheiten für beliebige aten sie stellen Speicherplatz zur Verfügung und Funktionalitäten für Zugriff und Manipulation sie besitzen innere Invarianten, die von lgorithmen ausgenutzt werden können Zugriff Manipulation Invariante rray/matrix direkt per Index zuweisen aten bleiben am Platz Liste sequenzielle Suche ein-/ausfügen rhalt der Reihenfolge Stack nur letzter intrag ein-/ausfügen last in first out Queue nur erster intrag ein-/ausfügen first in first out Heap nur größtes lem. ein-/ausfügen Heapeigenschaft lle anderen atenstrukturen bestehen wieder aus rrays und/oder Listen rrays sind geeignet, wenn der Speicherbedarf beschränkt ist der Zugriff schnell sein soll die Ordnung unwichtig oder untergeordnet ist Listen sind geeignet, wenn der Speicherbedarf nicht absehbar ist Umordnung schnell sein soll der Zugriff unwichtig oder untergeordnet ist

2 Stack im omputer Heap im omputer Stack als rray top top Stack als Liste implizite aumstruktur top Heap als rray top 7 9 Heap als aum explizite aumstruktur Queue im omputer aum im omputer Queue als rray head tail aum als rray Queue als Liste aum 5 aum als Zeigerstruktur head tail

3 atenstrukturen in JV Ziele von lgorithmen In JV könnte man folgende bstraktion der Funktionalitäten machen: public interface atastructure { public void initialize ( ) ; // make empty public boolean ismpty ( ) ; // is structure empty? public void insert ( obj ) ; // insert obj public getnext ( ) ; // get next public void remove ( ) ; // remove top public void remove ( obj ) ; // remove obj (oma II) public search ( obj ) ; // find back obj (oma II) } public class Stack implements atastructure {... } public class Queue implements atastructure {... } public class Heap implements atastructure {... } public class SearchTree implements atastructure {... } // (oma II) public class HashTable implements atastructure {... } // (oma II) mathematische lgorithmen können zwei mögliche Ziele haben: etwas berechnen, z.. einen Wert oder ein rray von Werten eine Menge von (mathematischen) Objekten erzeugen esignkriterien sind dabei Korrektheit möglichste infachheit Verständlichkeit Sparsamkeit in Zeit und Speicher (zumeist in Konflikt miteinander) Iteration und Rekursion sind mögliche Prinzipien, um das zu erreichen Rekursion kann einfach sein, wo iterative nsätze kompliziert sind und umgekehrt Rekursion ist das Prinzip, ein Problem auf ein oder mehrere kleinere Probleme gleicher rt zurück zu führen induziert einen baumartigen Verfahrensablauf (statt linear bei Iteration) iterativer lgorithmus Zwischen zustände H H F G I I F G rekursiver lgorithmus

4 kleinere Unterprobleme finden eispiel für einfache Rekursion: das Türme-Problem ist einfach, wenn Problem rekursiv formuliert ist, z..!, n! n (n )! F, F, F n F n + F n 2 ist ansonsten die Kunst beim ntwurf rekursiver lgorithmen kann Rekursion beenden, wenn Teilproblem direkt lösbar divide and conquer: Rekursion kann am effizientesten sein, wenn Teilprobleme nur ruchteile des usgangsproblems groß sind gutes eispiel: Mergesort, Multiplikation von ualzahlen akzeptables eispiel: Quicksort schlechtes eispiel: Stoogesort ( U vom 4.2.5) ufgabe 48: uf wieviele Weisen können n Schachtürme so auf ein n n- rett gestellt werden, dass sie einander nicht angreifen können? eispiel für ffizienz: Mergesort as Türme-Problem rray Kombinatorische ntwort: bbildung auf die Permutationen Rekursionstiefe nur O(log n) und ufwand O(n/2 Tiefe ) pro Knoten (n Länge des rrays) n! Möglichkeiten

5 !" '( # $ Rekursionsbaum des Türme-Problems bene bene bene 2 bene 3 n rekursive Lösung des Türme-Problems tuerme( n ) Input: Größe n des Schachbretts Output: usgabe aller zulässigen Turmstellungen initialisiere rray turm[] { Spalten } der Länge n mit { Zeilen } place( ) place( i ) Input: Index i der rettzeile if i n + then { Positionen } gebe turm[] aus { (turm[j], j)j } else for j : to n do { Spalten } if turm[j] then turm[j] : i { } place( i + ) turm[j] : { } endfor!"!"!! ""!" '( '( '( '( '' (( '( '( '( # $ # $ # $ # $ ## $$ # $ # $ # $ ufwand der Türme-Rekursion R(3) 4 T(3) 6 R(2) 3 T(2) 5 R() 2 T() 2 R(n + ) R(n) + T (n + ) (n + )T (n) ufwand der Türme-Rekursion ehauptung: R(n) n + für n T (n) e n! für n eweis: R(n) analog Fibonacci-Folge. T (n) n! nt (n ) + n! T (n ) (n )! + n! ( T (n 2) (n 2)! + (n )! ) + n!... T () +! k k2 k! e (n ) k! wobei T () 2

6 eispiel für kompliziertere Rekursion: das Geldwechselproblem Lösung des Geldwechselproblems w 4 uro 2x x x enumerate( b, s, k ) Input: (restlicher) Geldbetrag b, akt. nzahl Scheine s, Index k w 2 3 uro w 3 uro nzahl Scheine 2 6 x 2x x 2x 3x 6x (keine Verbesserung mehr 4x 7x x möglich) x x 3x 2x x x 4 7 Minimum if k n then { Rekursionsende } if b mod w n then { Geldbetrag geht auf } r n : b / w n s : s + r n { restliche Scheine addieren } if s min > s then { bessere Lösung gefunden } s min : s { estwerte merken } r min : (r,..., r n ) as Geldwechselproblem (ufgabe 53) Lösung des Geldwechselproblems minhange(, { w i } i ) Input: Geldbetrag Menge möglicher Scheinwerte { w,..., w n }, w i n Output: Paar (r, s) mit r k w k, wobei s k k r k minimal ist initialisiere Vektor r min der Länge n { Lösungsvektor } s min : { minimale nzahl } enumerate(,, ) { rekursiver rstaufruf } else { if k n } if s s min then { keine Verbesserung möglich } return for r k : to b / w k do { wählbare Ratenanzahlen } enumerate( b r k w k, s + r k, k + ) { rekursiver ufruf } endfor return ( r min, s min )