Überblick und Ziele. Kapitel 11: Rekursion. Rekursive Algorithmen und Methoden. Beispiel für einen rekursiven Algorithmus

Transkript

1 Eiführug i die Iformati: Programmierug ud Softwareetwiclug Witersemester 08/9 Überblic ud Ziele Kapitel : Reursio Prof. Dr. David Sabel Lehr- ud Forschugseiheit für Theoretische Iformati Istitut für Iformati, LMU Müche Das Prizip der Reursio ud reursiver Berechuge verstehe. Implemetierug reursiver Methode i Java Verschiedee Forme der Reursio Quicsort als reursive Methode zum Sortiere eies Arrays WS 08/9 Stad der Folie: 9. Jauar 09 Die Ihalte dieser Folie basiere mit freudlicher Geehmigug tlw. auf Folie vo Prof. Dr. Rolf Heicer aus dem WS 07/8 ud auf Folie vo PD Dr. Ulrich Schöpp aus dem WS 00/ D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Reursive Algorithme ud Methode Begriffsheruft: lateiisch recurrere zurüclaufe Defiitio (reursiver Algorithmus) Ei Algorithmus ist reursiv, we i seier (edliche) Beschreibug derselbe Algorithmus wieder aufgerufe wird. Beispiel für eie reursive Algorithmus Treppe mit Stufe hochsteige: We = 0, da fertig, asoste: Steige die erste Stufe hoch Treppe mit Stufe hochsteige. Ei reursiver Algorithmus ist daher selbstbezüglich defiiert I Java öe reursiver Algorithme durch reursive Methode implemetiert werde. Defiitio (reursive Methode) Eie Methode ist reursiv, we i ihrem Rumpf (Aweisugsteil) die Methode selbst wieder aufgerufe wird. D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort {{ Treppe mit Stufe {{ Treppe mit Stufe D. Sabel Reursio WS 08/9 4/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

2 Allgemeies Prizip der Reursio Eifache Beispiele Basisfall: Das ist der eifache Fall, für de ma das Ergebis sofort weiß (z.b. 0 Stufe) Reursiver Aufruf: Mache das Problem etwas leier, idem ei leier Teil gelöst wird. Für das etwas leiere Restproblem mache de reursive Aufruf (die Reursio ümmert sich um die Lösug) (z.b. eie Stufe hochsteige, de Rest der Treppe reursiv hochsteige) Wichtig dabei: Das Problem muss echt leier werde ud der Basisfall muss irgedwa erreicht werde, aderefalls termiiert das Programm icht. Die Faultät eier Zahl IN ist defiiert durch 0! = ud! = ( ) für alle IN mit > 0 Z.B. ist 5! = 0, de 5! = 5 4 Reursive Defiitio der Faultät: 0! =! = (( )!) für alle IN mit > 0 Z.B. 5! = 5 4! = 5 4! = 5 4! = 5 4! = 5 4 0! = 5 4 =... = 0 D. Sabel Reursio WS 08/9 5/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 6/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Reursive Berechug der Faultät i Java Auswertug reursiver Methodeaufrufe Wir betrachte als Beispiel: it = fac () ; public static it fac ( it ) { if ( == 0) { retur ; // Basisfall else { retur * // selbst gel " oster Teil fac ( -) ; // reursiver Aufruf Im erste Schritt wird auf dem Stac ei Speicherplatz für die Variable agelegt: Beim Methodeaufruf wird ebe Variable für die atuelle Parameter auch eie Variable für das Ergebis agelegt. D. Sabel Reursio WS 08/9 7/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 8/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

3 Illustratio des Stacaufbaus Illustratio des Stacaufbaus * * * * * * = if ( == 0) {retur ; else {retur *fac(-); * if ( == 0) {... else {retur *fac(-) * if ( == 0) {... else {retur *fac(-); D. Sabel Reursio WS 08/9 9/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 0/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Illustratio des Stacaufbaus Illustratio des Stacabbaus fac(0) 0 fac(0) 0 fac(0) 0 0 *fac(0) *fac(0) *fac(0) fac(0) * * * *fac(0) * * * * * * * * *fac(0) if ( == 0) {retur ; else {retur *fac(-); retur D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

4 Illustratio des Stacabbaus Termiierug Der Aufruf eier reursive Methode termiiert, we ach edlich viele reursive Aufrufe ei Abbruchfall erreicht wird. Beispiele: * 6 6 public static it oterm ( it ) { retur * oterm ( -) ; Aufruf vo oterm(0) termiiert icht, da ei Abbruchfall erreicht wird (i Java erhalte wir eie StacOverflowError) public static it fac ( it ) { if ( == 0) { retur ; // Basisfall else { retur * // selbst gel " oster Teil fac ( -) ; // reursiver Aufruf fac(x) termiiert für x 0, aber icht für x < 0! D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 4/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Beispiele Reursio ud Iteratio () public static it oterm ( it ) { if ( == 0) { retur 0; else { retur oterm ( -) ; termiiert für gerade positive Zahle, aber icht für ugerade oder egative Zahle. public static it collatz ( it ) { if ( ==) { retur ; else if ( % == 0) { retur collatz ( /) ; else { retur collatz (* +) ; Bis heute ist icht bewiese, ob diese Futio für jede positive atürliche Zahl termiiert (siehe Collatz-Vermutug) Zu jedem reursive Algorithmus gibt es eie sematisch äquivalete iterative Algorithmus, d.h. eie Algorithmus mit Wiederholugsaweisuge, der dasselbe Problem löst. Beispiel: Faultät iterativ: static it faciterativ ( it ) { it result = ; while (!= 0) { result = result * ; - -; retur result ; Vorteil des iterative Algorithmus: Der Stac wächst icht liear, soder beötigt ur zwei Speicherplätze (für result ud ). D. Sabel Reursio WS 08/9 5/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 6/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

5 Reursio ud Iteratio () Reursio: Türme vo Haoi Reursive Algorithme sid häufig elegater ud übersichtlicher als iterative Lösuge. Gute Compiler öe aus reursive Programme auch effiziete Code erzeuge; trotzdem sid iterative Programme meist scheller als reursive. Für mache Problemstelluge a es wesetlich eifacher sei, eie reursive Algorithmus azugebe als eie iterative.... Startsituatio D. Sabel Reursio WS 08/9 7/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 8/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Reursio: Türme vo Haoi Beispiel =... Zielsituatio D. Sabel Reursio WS 08/9 8/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 9/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

6 Löse durch Reursio: Reursioafag Löse durch Reursio: Reursioafag = : Verschiebe Scheibe vo Startstapel auf Zielstapel = : Verschiebe Scheibe vo Startstapel auf Zielstapel D. Sabel Reursio WS 08/9 0/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 0/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Löse durch Reursio: Reursiosschritt Löse durch Reursio: Reursiosschritt.... Verschiebe de Turm der Höhe reursiv auf de Hilfsstapel. Verschiebe Scheibe auf de Zielstapel... D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

7 Löse durch Reursio: Reursiosschritt Pseudo-Algorithmus.... Verschiebe de Turm der Höhe reursiv auf de Zielstapel verschiebe(,start,ziel,hilf). We >, da verschiebe(-,start,hilf,ziel). Schiebe Scheibe vo start auf ziel. We >, da verschiebe(-,hilf,ziel,start) Reursioafag ist bei = : eie reursive Aufrufe Beachte: Zwei reursive Aufrufe pro Reursiosschritt Java-Programme: I der Übug D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Fiboacci-Zahle: Reursiv Beispiel: Kaiche Reursive Defiitio der Fiboacci-Zahle: fib(0) = fib() = fib() = fib( ) + fib( ) für alle IN mit Java-Implemetierug als reursive Methode: public static it fib ( it ) { if ( <= ) { retur ; else retur fib ( -) + fib ( -) ; Im Jahr 0 wird Kaichepaar gebore. Im Jahr hat dieses Paar ei eues Paar gebore. I jedem Jahr habe die ei- ud zweijährige Paare jeweils ei eues Paar gebore. Azahl der im Jahr eu geboree Kaichepaare:? D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 4/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

8 Kasade reursiver Aufrufe fib() = fib() = fib(0) = fib() = fib() = fib(5) =8 fib(0) = fib() = fib() = fib(4) =5 fib() = fib() = fib() = fib(0) fib() = = Die Zeitomplexität der reursive Fiboacci-Futio ist expoetiell, d.h. i O( ). Grud: -Schritte i die Tiefe, i jedem Schritt wird die Azahl der reursive Aufrufe ugefähr verdoppelt. D. Sabel Reursio WS 08/9 5/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Fiboacci-Zahle iterativ bereche Idee: Bereche vo fib(0) ud fib() begied aufsteiged: public static it fibiterativ ( it ) { it fibimius = ; // fib (0) = it fibimius = ; // fib () = it fibi = ; for ( it i =; i <= ; i ++) { // fib (i) = fib (i -) + fib (i -) fibi = fibimius + fibimius ; // Verschiebe i um : fibimius = fibimius ; // fib (i -) wird fib (i -) fibimius = fibi ; // fib (i -) wird fib ( i) retur fibi ; Die Zeitomplexität ist liear, d.h. i O() (da die for-schleife mal durchlaufe wird ud jeder Schleifedurchlauf ostate Zeit beötigt. Die Speicherplatzomplexität ist ostat, d.h. i O(), da ur ostat viele Variable verwedet werde. D. Sabel Reursio WS 08/9 6/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Reursiosforme Die Acerma-Futio Lieare Reursio: I jedem Zweig der Falluterscheidug ommt höchstes ei reursiver Aufruf vor, z.b. Faultätsfutio fac. Baumreursio (Kasadeartige Reursio): Meherere reursive Aufrufe stehe ebeeiader ud sid durch Operatioe verüpft, z.b. Fiboacci-Zahle fib Verschachtelte Reursio: Reursive Aufrufe omme i de Parameter vo reursive Aufrufe vor, z.b. Acerma-Futio. public static it ac ( it, it m) { if ( == 0) { retur m +; else if ( m == 0) { retur ac ( -,) ; else { retur ac ( -, ac (,m -) ); verschachtelte Reursio Die Acerma-Futio wächst extrem schell Sie ist das lassische Beispiel für eie berechebare, termiierede Futio, die icht primitiv-reursiv ist (erfude 96 vo Acerma) Beispiele: ac(4, 0) = ac(4, ) = 655 ac(4, ) = 6556 ac(4, 4) > Azahl der Atome im Uiversum D. Sabel Reursio WS 08/9 7/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 8/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

9 Quicsort Quicsort ist ei scheller (vergleichsbasierter) Sortieralgorithmus (etwicelt vo Toy Hoare, 96). Idee: Falls das zu sortierede Array midestes Elemete hat:. Wähle irgedei Elemet aus dem Array als Pivot ( Dreh- ud Agelput ), z.b. das erste Elemet.. Partitioiere das Array i eie lie ud eie rechte Teil, so dass alle Elemete im lie Teil leier-gleich als das Pivot sid, alle Elemete im rechte Teil größer als das Pivot sid.. Wede Quicsort (reursiv) auf beide Teilarrays a. Der Quicsort folgt eie ähliche Lösugsasatz wie die biäre Suche. Diese Asatz et ma Divide-ad-Coquer ( Teile ud beherrsche ) Quicsort: Beispiel Wähle Pivot, z.b Partitioiere ahad des Pivots 4 6 {{ {{ < Sortiere beide Teilarrays reursiv mit Quicsort D. Sabel Reursio WS 08/9 9/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 0/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Implemetierug i Java Eifache Variate vo partitio public static void quicsort(it[] arr) { // sortiere alle Elemete des Arrays: qsort(arr, 0, arr.legth-); public static void qsort(it[] arr, it left, it right) { // sortiere de Tellbereich vo left bis right i arr if (left < right) { // mehr als ei Elemet zu sortiere // w"ahle erstes Elemet als Pivot it pivot = arr[left]; // partitioiere ahad des Pivot-Elemets it pivotidex = partitio(arr,left,right,pivot); // sortiere lie ud rechte Teil reursiv qsort(arr,left,pivotidex-); qsort(arr,pivotidex+,right); Es fehlt och die Methode: partitio Idee: partitio(it[] arr,left,right,pivot) partitioiert das Array arr im Bereich left bis right ahad des Pivots pivot ud liefert de Idex des Pivotelemets. Beutze Kopie copy des Teilbereichs Durchlaufe copy dreimal um die Werte i arr[left..right] zu überschreibe:. Schreibe die Werte leier als das Pivot. Schreibe die Werte gleich zum Pivot. Schreibe die Werte größer als das Pivot Dabei muss der Rücgabewert für de Idex auf das Pivotelemet etspreched verwaltet werde. D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

10 Eifache Variate vo partitio public static it partitio(it[] arr, it left, it right, it pivot) { it[] copy = ew it[right-left+]; // erstelle Kopie des zu sortierede Teils for (it i=0; i < copy.legth; i++) {copy[i] = arr[left+i]; it pivotidex = left-; it writepos = left; // Schreibe lie Teil for (it i=0; i < copy.legth; i++) {if (copy[i] < pivot) { arr[writepos] = copy[i]; pivotidex++; writepos++; // Schreibe alle Elemete gleich zum Pivot for (it i=0; i < copy.legth; i++) {if (copy[i] == pivot) { arr[writepos] = copy[i]; pivotidex++; writepos++; // Schreibe rechte Teil for (it i=0; i < copy.legth; i++) {if (copy[i] > pivot) { arr[writepos] = copy[i]; writepos++; retur pivotidex; D. Sabel Reursio WS 08/9 /4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Speicherplatzomplexität Da partitio eie Kopie des Arrays im Speicher hält, beötigt dieser Quicsort für ei Array der Läge, O() (zusätzliche) Speicherplatz. Wir betrachte daher eie optimierte Variate. D. Sabel Reursio WS 08/9 4/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Partitoiere ohe zusätzliche Platzbedarf () Idee: l l lr lr r we l ud r sich och icht gereuzt habe: Schiebe l solage ach rechts, bis eie Zahl größer als das Pivot gefude wird. Schiebe r solage ach lis, bis eie Zahl leier als das Pivot gefude wird. We sich dabei l ud r icht gereuzt habe, vertausche die Eiträge ud mache weiter mit. Vertausche das Pivot mir r D. Sabel Reursio WS 08/9 5/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Partitioiere ohe zusätzliche Platzbedarf () public static void swap(it[] arr, it l, it r) { it tmp = arr[l]; arr[l] = arr[r]; arr[r] = tmp; public static it partitio(it[] arr, it left, it right, it pivot) { // i-place partitio, geht davo aus, dass pivot sich a arr[left] befidet it l = left+; // fage lis ebe dem Pivot a it r = right; // fage rechts gaz rechts a boolea proceed = true; // vertausche weiter? while (proceed) { while (l <= right && arr[l] < pivot) {l++; // schiebe l ach lis bis ei zu gro"sses Elemet gefude while (r >= left && arr[r] > pivot) {r--; // schiebe r ach rechts bis ei zu leies Elemet gefude if (l < r) { swap(arr,l,r); // vertausche arr[l] ud arr[r] l++; r--; // schiebe l ach lis ud r ach rechts else {proceed = false; //stoppe // setze Pivot a die richtige Positio swap(arr,left,r); // r ist das erste zu leie Elemet vo rechts retur r; D. Sabel Reursio WS 08/9 6/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

11 Platzbedarf der optimierte Variate Komplexität vo Quicsort () Es werde ebe der Eigabe ur ostat viele loale Variable verwedet. Aber: Die reursive Aufrufe werde auf dem Stac abgelegt. Daher: Platzbedarf ist abhägig vo der maximale Reursiostiefe! Sei die Läge des Eigabearrays. Der Zeitbedarf zum Partitioiere eies Teilarrays mit m Eiträge ist i alle Fälle i O(m), da l ud r stets um midestes erhöht bzw. um eriedrigt werde, ud isgesamt weiger als r l < m solche Veräderuge möglich sid. Alle Partitioieruge i gleicher Reursiostiefe (d.h. ach -maligem Aufruf vo qsort) beötige i der Summe daher Zeit i O(). Zur Laufzeitabschätzug müsse wir daher wisse, wie oft partitioiert werde muss. D. Sabel Reursio WS 08/9 7/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 8/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Komplexität vo Quicsort () Im beste Fall halbiert das Partitioiere jedesmal, d.h. die Elemete werde gleichmäßig i de lie ud rechte Teil verteilt. Da müsse wir icht öfter als (log ) + mal partitioiere. Daher ist die best-case Laufzeitomplexität vo Quicsort i O( log ). Etspreched ist die Platzomplexität im best-case O(log ) für die reursive Aufrufe auf dem Stac. Im schlechteste Fall ist eie Partitio stets leer, ud die adere ethält alle Elemete außer dem Pivot. Da müsse wir -mal partitioiere. Daher ist die worst-case Laufzeitomplexität vo Quicsort i O( ) ud die worst-case Platzomplexität i O(). Ma a zeige, dass im Durchschitt immer och O(log ) reursive Aufrufe ausreiche, daher ist die average-case Laufzeitomplexität vo Quicsort i O( log ) ud die Platzomplexität im Mittel i O(log ). D. Sabel Reursio WS 08/9 9/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort Verbesseruge des Quicsort-Algorithmus Pratische Verbesseruge We Arrays urz werde (z.b. 0 Elemete), verwede eifache Sortieralgorithmus (z.b. Selectio Sort) Bestimme Pivotelemet durch Ziehe vo Elemete: erstes Elemet mittleres Elemet letztes Elemet Wähle Pivot als Media der Elemete. Teile das Array i Teile: < als Pivot, = Pivot, > Pivot. Der mittlere Teil wird icht mehr im reursive Aufruf berücsichtigt. Stare Beschleuigug bei viele gleiche Elemete. D. Sabel Reursio WS 08/9 40/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort

12 Bemeruge: Sortiere Zusammefassug Ma a achweise, dass jeder vergleichsbasierte Sortieralgorithmus im worst-case log-liear ist. Es gibt Sortierverfahre, die auch im worst-case dies erreiche (z.b. Merge-Sort) Für icht-vergleichsbasierte Sortierverfahre (z.b. vo Gazzahle fester Läge) sid auch lieare Verfahre beat. Prizip der Reursio: Basisfall, Reursiver Aufruf Auf Termiierug achte! Reursiosforme: lieare Reursio, Baumreursio, Verschachtelte Reursio Iterativ vs. Reursio Beispiele (Türme vo Haoi, fac, fib, acerma) Quicsort als reursives ud schelles Sortierverfahre D. Sabel Reursio WS 08/9 4/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort D. Sabel Reursio WS 08/9 4/4 Reursio Re.+Iteratio Haoi Re.-Forme Quicsort