Institut für Kartographie und Geoinformation Prof. Dr. Lutz Plümer Diskrete Mathematik I Vorlesung 4 04.11.99 -Rekursion-

Präsentation zum Thema: "Institut für Kartographie und Geoinformation Prof. Dr. Lutz Plümer Diskrete Mathematik I Vorlesung 4 04.11.99 -Rekursion-"—  Präsentation transkript:

1 Institut für Kartographie und Geoinformation Prof. Dr. Lutz Plümer Diskrete Mathematik I Vorlesung 4 04.11.99 -Rekursion-

2 2 Übersicht Das Prinzip der Rekursion Beispiel 1: Fakultätsfunktion Beispiel 2: QuickSort –„Teile und Herrsche“ –Konstruktion der Partition mit einem(!) Array –Wahl eines guten Anfangselements –Programmkonstrukte von Java –Quicksort: Umsetzung in Java –Funktion „RekQuickSort“ –Funktion „Swap“ (Vertauschen zweier Elemente)

3 3 Das Prinzip der Rekursion Eine rekursive Definition reduziert ein Problem auf ein kleineres Problem derselben Art. Eine rekursive Funktion setzt eine rekursive Definition in ein Programm um.

4 4 Definition: Für n  0 gilt Beispiel 1: Fakultätsfunktion

5 5 Fakultät int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; }

6 int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(4)

7 int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } 4 != 0 fak(4)

8 int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } 4 > 0 fak(4)

9 int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } 4 * fak(3) fak(4)

10 4 * fak(3) fak(4)fak(4)=4*fak(3) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(3)

11 fak(4)=4*fak(3) 3 != 0 fak(3) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; }

12 fak(4)=4*fak(3) 3 > 0 fak(3) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; }

13 fak(4)=4*fak(3) 3 * fak(2) fak(3) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; }

14 fak(4)=4*fak(3) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } 3 * fak(2) fak(3)fak(3)=3*fak(2) fak(2)

15 fak(4)=4*fak(3)fak(3)=3*fak(2) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } 2 * fak(1) fak(2)

16 fak(4)=4*fak(3) fak(3)=3*fak(2) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(3)=3*fak(2) 2 * fak(1) fak(2)fak(2)=2*fak(1) fak(1)

17 fak(4)=4*fak(3)fak(3)=3*fak(2)fak(2)=2*fak(1) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } 1 * fak(0) fak(1)

18 fak(4)=4*fak(3) fak(3)=3*fak(2) fak(2)=2*fak(1) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(2)=2*fak(1) 1 * fak(0) fak(1)fak(1)=1*fak(0) fak(0)

19 fak(4)=4*fak(3)fak(3)=3*fak(2)fak(2)=2*fak(1)fak(1)=1*fak(0) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } n = 0 fak(0)

20 fak(4)=4*fak(3)fak(3)=3*fak(2)fak(2)=2*fak(1)fak(1)=1*fak(0) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } 1 fak(0)

21 fak(4)=4*fak(3)fak(3)=3*fak(2)fak(2)=2*fak(1)fak(1)=1*fak(0) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(0) = 1

22 fak(4)=4*fak(3)fak(3)=3*fak(2)fak(2)=2*fak(1)fak(1)=1*fak(0) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(0) = 1

23 fak(4)=4*fak(3)fak(3)=3*fak(2)fak(2)=2*fak(1) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(1)=1*1

24 fak(4)=4*fak(3)fak(3)=3*fak(2)fak(2)=2*fak(1) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(1)=1

25 fak(4)=4*fak(3)fak(3)=3*fak(2)fak(2)=2*fak(1) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(1) = 1

26 fak(4)=4*fak(3)fak(3)=3*fak(2) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(2) = 2*1

27 fak(4)=4*fak(3)fak(3)=3*fak(2) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(2) = 2

28 fak(4)=4*fak(3)fak(3)=3*fak(2) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(2) = 2

29 fak(4)=4*fak(3) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(3) = 3*2

30 fak(4)=4*fak(3) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(3) = 6

31 fak(4)=4*fak(3) int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(3) = 6

32 int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(4) = 4*6

33 int fak(int n) { if(n==0) return 1; else if (n>0) return n * fak(n-1); else return -1; } fak(4) = 24

34 34 Beispiel 2: QuickSort einer der schnellsten Sortieralgorithmen Grundidee: „Teile und Herrsche“ (“divide and conquer“) - ein wichtiges Paradigma für geometrische Algorithmen rekursiver Algorithmus

35 35 Sortierfeld A mit n Elementen Wahl eines Wertes W des Feldes „Teile und Herrsche“

36 36 W Konstruktion einer Partitionierung des Feldes „Teile und Herrsche“

37 37 A1A1 A2A2 W 1 l-1 l+1n Sortieren von A 1 und A 2 durch Rekursion „Teile und Herrsche“ alle Elemente von A 1 sind <= W (noch unsortiert) alle Elemente von A 2 sind >= W (noch unsortiert)

38 38 Konstruktion der Partition mit einem(!) Array Wahl eines Elementes W im Inneren des Array Suchen eines i von links an mit A[ i ] >= W Suchen eines j von rechts an mit A[ j ] <= W Vertauschen von A[ i ] und A[ j ] Wiederhole dies, bis i >= j gilt

39 39 4537169 W = 7 Konstruktion der Partition mit einem(!) Array Suchen eines i von links an mit A[ i ] >= W Suchen eines j von rechts an mit A[ j ] <= W Vertauschen von A[ i ] und A[ j ]

40 40 4537169 Konstruktion der Partition mit einem(!) Array Suchen eines i von links an mit A[ i ] >= W Suchen eines j von rechts an mit A[ j ] <= W Vertauschen von A[ i ] und A[ j ] W = 7

41 41 W = 7 rekursiv weitermachen 4536179 Konstruktion der Partition mit einem(!) Array Suchen eines i von links an mit A[ i ] >= W Suchen eines j von rechts an mit A[ j ] <= W Vertauschen von A[ i ] und A[ j ] Wiederhole dies, bis i >= j gilt

42 42 das mittlere von links(Low)4 mitte(Middle)1 rechts(High)9 4531769 Wahl eines guten Anfangselements vertausche 4 und 1

43 43 das mittlere von links(Low)4 mitte(Middle)1 rechts(High)9 Wahl eines guten Anfangselements 1534769 vertausche 4 und 1

44 44 a / b ganzzahlige Division, wenn beide Operanden ganzzahlig Iteration wiederhole die Anweisung solange die Bedingung erfüllt ist a) Überprüfen der Bedingung vor Schleifeneintritt while (Bedingung) do Anweisung b) Überprüfen der Bedingung nach Schleifeneintritt do Anweisung while (Bedingung) Programmkonstrukte von Java

45 45 void QuickSort (char[] A) { int Hi = A.length-1; RekQuickSort ( A, 0, Hi); } Quicksort: Umsetzung in Java

46 46 void RekQuickSort (char[] A, int Lo, int Hi) { int li = Lo; int re = Hi; int mid = (li+re)/2; if (A[li] > A[mid]) Swap(A, li, mid); if (A[mid] > A[re]) Swap(A, mid, re); if (A[li] > A[mid]) Swap(A, li, mid); Funktion „RekQuickSort“

47 if((re - li) > 2) { char w = A[mid]; do { while(A[li] < w) li++; while(w < A[re]) re--; if(li <= re) { Swap (A, li, re); li++; re--; } }while(li <= re); if(Lo < re) RekQuickSort (A, Lo, re); if(li < Hi) RekQuickSort (A, li, Hi); }

48 private void Swap (char [] A, int i, int k) { char h = A[i]; A[i] = A[k]; A[k] = h; } Funktion „Swap“ (Vertauschen zweier Elemente)