Rekursjon I. TRE AV REKURSIVE KALL, II. INDUKTIVE DATA TYPER IV. STABEL AV REKURSIVE KALL V. KORREKTHET. rekursjonsdybde terminering ordning

Transkript

1 Rekursjon I. TRE AV REKURSIVE KALL, rekursjonsdybde terminering ordning II. INDUKTIVE DATA TYPER og Rekursjon over slike III. SPLITT OG HERSK ROBLEMLflSNING P VED REKURSJON IV. STABEL AV REKURSIVE KALL iterasjon til rekursjon rekursjon implementert som iterasjon V. KORREKTHET terminering invarianter i-0 : H Rekursjon:

2 . En metode kaller seg selv /** en heltallsfunksjon fakultet (factorial (!)) defineres som * 0! = * (n+)! = (n+) * n! */ /** Algoritme som beregner fact(n) n >= 0 fact(n) ingen unntak **/ int fact( int n ) { int r = ; while (n > ) r = r * n; n = n ; return r; int fact( int n ) { if (n <= ) return ; else return n * fact( n ); fact(n) vil alltid terminere Hvorfor? Hva med: int hack( int n ) { if (n <= ) return ; else return n * hack( n+ ); i-0 : H Rekursjon:

3 . En metode kaller seg selv /** heltallsfunksjon fact (!): int fact( int n ) { * 0! = if (n <= ) return ; * (n+)! = (n+) * n! else return n * fact( n ); */ fact( 3 ) { n = 3 <= NEI 3 * 6 fact( ) { n = <= NEI * fact( ) { n = <= JA i-0 : H Rekursjon: 3

4 . Rekursjonstre og -dybde fact(0) = 0 fact(0) = fib(n+) = (n+) * fact(n) f(4) f(3) int fact(int n) { if (n <= ) return ; else return n * fact(n-); returner i basistilfelle f() ellers beregn rekursivt enklere (mindre) deler og sett disse sam- f(4)...? f(3)...? f()...? f()...? > > > 6 > 4 rekkef lgen av kall f() rekursjonsdybde #svarte = #r de linjer = # rekursive kall... inntil basistilfelle er nådd (=høyden av treet) 6 4 tre av rekursive kall

5 . Rekursjonstre og -dybde; Eks: Fibonacci-tallene fib(0) = 0 fib() = fib(n+) = fib(n) + fib(n+) f() f() f(3) f(0) 3 f() f(4) 5 f() int fib(int n) { if (n==0 n==) return ; else return fib(n-) + fib(n-); returner i basistilfelle f() f(0) ellers beregn rekursivt enklere (mindre) deler og sett disse sam- tre av rekursive kall f(4)...? f(3)...? rekkef lgen f()...? av kall f()...? > f(0)...? > > f()...? > > 3 f()...? f()...? > f(0)...? > > > 5 rekursjonsdybde #svarte = #r de linjer = # rekursive kall... inntil basistilfelle er nådd (=høyden av treet) i-0 : H Rekursjon: 5

6 Rekursjonstre og -dybde; Quicksort Rekursjon som en generell strategi for problemløsning og algoritmedesign Gitt en instans n av et problem P :. hva gjør jeg når n er basis tilfelle. hvordan konstruere løsning for n utfra løsninger for noen instanser mindre enn n P = sorter input array A /* int[] SS(int[] A,k) { * initielt kall med SS(A,0) * n = A.length; * if (k==n-) { return A; * else { * i= indeksen til minste elementet * i A[k...n-]; * bytt A[k] med A[i]; * return SS(A, k+); */ /* int[] QuickSort ( int[] A ) { * int n = A.length; * if (n == ) { return A; * else { * p = A[n/] pivot * t = [x : x ε A & x < p] og t3 = [x : x ε A & x > p]; * t = [x : x ε A & x = p] ; * sorter rekursivt begge (mindre) array * r = QuickSort ( t ) og * r3 = QuickSort ( t3 ) * return r + t + r3 * * */ i-0 : H Rekursjon: 6

7 QS [4 3 5] p=3 QS [ ] m= QS [] 3 QS [ 4 5 ] p=4 4 QS [5] QS ( Ar[l...h] ) n = Ar.lenght if (n == ) return Ar; else p = A[n/]; return QS ( Ar[< p] ) + Ar[= p] + QS ( Ar[> p] ) [ ] 3 + [ 4 5] + [ 3 4 5] i-0 : H Rekursjon: 7

8 * pre-, post- og (for binære trær) innorden + 3 inn(t) = if (T =! null) { inn(t.left) write(t.data) inn(t.right) + * 3 pre(t) = if (T =! null) { write(t.data) pre(t.left) pre(t.right) * + 3 post(t) = if (T =! null) { post(t.left) post(t.right) write(t.data) + 3 * innp(t) = if (T =! null) { write( ( ) innp(t.left) write(t.data) innp(t.right) write( ) ) ( ( () + () ) * (3) ) Skriv resultater av kallene inn(t), pre(t), post(t) for f lgende tr r T,T T * T * + * i-0 : H Rekursjon: 8

9 . Induktive Data Typer (vilkårlig store men endelige) Strukturell ordering naturlige tall N: basis: 0 er et N array av N: A(N) basis 0 -> N er A(N) hvis n er et N hvis [0...k] -> N er A(N) s er: n+ et N s er [0...k,k+] -> N en A(N) Lister av N: L(N): basis: null er en L(N) hvis s er: L er L(N) og n er N (n,l) en L(N) L L n 0 N 0... N k k+ n 0 N < < L 0... N k L < 0... N k k+ < n Bin re T r r av N: BT(N): basis: null er et BT(N) t n < t < hvis t, t er BT(N) og n er N t n n s er: (t, n, t) et BT(N) t t t t i-0 : H Rekursjon: 9

10 . Induktiv oppbygging -> rekursive beregninger induktiv definisjon = fra basis og oppover ***** rekursjon = fra toppen mot basis Nat int fib(n) { int fact(n) { basis: 0 if (n==0 n==) return ; if (n <= 0) return ; ind: n+ else return fib(n-) + fib(n-); else return n * fact(n-); Array[Int] void inc(int[] A, int k) { int sum(int[] A, int k) { basis: [0] -> Int A[k]++; if (k==0) return A[0]; ind: [0.. k-, k] -> Int if (k > 0) inc(a,k-); else return A[k] + sum(a,k-); Liste[Int] class LS { void inc(ls L) { int sum(ls L) { basis: null int n; if (L==null) { if (L==null) return 0; ind: (n,hale) LS hale; else { n++; else return inc(l.hale); sum(l.hale) + n; Bin rtt re[int] class BT { void inc(bt B) { int sum(bt T) { basis: null int n; if (T==null) { if (T==null) return 0; ind: (left,n,right) BT left; else {n++; else return BT right; inc(t.left); n + sum(t.left) + sum(t.right) ; inc(t.right); FRAKTALer i-0 : H Rekursjon: 0

11 Hva beregnes av følgende...? f (x: int) = if (x <= 0) then 0 else x + f(x ) ; f(n) =? f (x: int) = if (x <= 0) then 0 else x*x + f(x ) ; f(n) =? f (x: int) = if (x <= 0) then 0 else + f(x ) ; f(n) =? f (x: int) = if (x <= 0) then 5 else f(x ) ; f(n) =? f (x: int) = if (x <= 0) then else f(x ) + f(x ) ; f(n) =? f (x: int) = if (x <= 0) then else * f(x ) ; f(n) =? f (x: int) = if (x <= ) then 0 else + f(x ) ; f(n) =? Tegn tre av rekursive kall for hver f-funksjon ved kall f(3); Gjensidig rekursjon: (La [] betegne en tom liste mens x::xs en liste med x som f rste elementet etterfulgt av listen xs; f.eks. listen [,,3] kan skrives som ::::3::[].) flat( [] ) = [] flat( l::ls ) = aux( l, ls ) aux( [], ls ) = flat( ls ) aux( x::xs, ls ) = x :: aux( xs, ls ) Hva slags argument (av hvilken type) forventes av flat? Hva blir resultatet av flat( [ [,], [,3] ] ) ;? av flat( [ [,], [,3], [], [4,5,6] ] ) ;? i-0 : H Rekursjon:

12 3. Splitt og hersk (engelsk: Divide and Conquer) Rekursjon som en generell strategi for problemløsning og algoritmedesign Gitt en instans n av et problem P :. hva gjør jeg når n er basis tilfelle?. hvordan konstruere løsning for n utfra løsninger for noen instanser mindre enn n? P(n) = bergen n. hva gjør jeg når n = 0? returner 0 =. hvordan konstruere løsning for n utfra løsning for n? n = * n-, altså returner * P(n ) P(0) = P(x) = if (x=0) then P(n+) = * P(n) else * P(n )

13 3. Splitt og hersk (engelsk: Divide and Conquer) Rekursjon som en generell strategi for problemløsning og algoritmedesign Gitt en instans n av et problem P :. hva gjør jeg når n er basis tilfelle. hvordan konstruere løsning for n utfra løsninger for noen instanser mindre enn n P = finn et gitt element x i en array A Hvis A er usortert : Hvis A er sortert... sjekk A[n]; hvis x ikke er der, lett i A[0...n ] /* initielt kall med FE(A, x?, A.length ) */ int FE(int[] A, x. k) { if (k < 0 ) return ; else if (A[k]==x) return k; else return FE(A, x, k ); FE(A, 7, ) BS(A, 7, 0,) /* initielt kall med * BS(A, x?, 0, A.length) */ int BS(int[] A, x, l, h) { m = (l+h) / ; if (l > h) return -; else if (A[m] == x) return m; else if (A[m] < x) return BS(A, x, m+, h); else return BS(A, x, l, m );

14 3. Splitt og hersk (engelsk: Divide and Conquer) Rekursjon som en generell strategi for problemløsning og algoritmedesign Gitt en instans n av et problem P :. hva gjør jeg når n er basis tilfelle?. hvordan konstruere løsning for n utfra løsninger for noen instanser mindre enn n? P(s) = les input strengen tegn-for-tegn s lenge det er et siffer, og returner heltallet (samt resten av strengen): P( 0 ) = (0,[]), P( 0sd ) = (, sd ), P( abcd ) = (0, abcd ), osv.. hva er basistilfelle? s er tom, eller d::rest der tegnet d ikke er et siffer, hva gjør jeg da? returnerer det akkumulerte resultatet og resten av strengen P(i, []) = (i, []) P(i, d::rest) = (i, d::rest). hvordan konstruere løsning for d::rest utfra løsning for rest (når d er et siffer)? i*0 + d er den nye akkumulerte tallverdien fortsett med P(i*0 + d, rest) parseint(s:string) = first( P(0,s) ); P(i,[]) = ( i, [] ) P(i,d::rest) = if (not digit(d)) then ( i, d::rest ) else P( i*0 + int(d), rest )

15 4. Iterasjon til rekursjon n > n */ int sumiter(int n) { int res =0; while (n > 0) { res = res + n; n = n ; return res; n > n */ int sumrek(int n) { if (n == 0) return 0; else return n + sumr(n-); Generellt, dog ikke 00% riktig: int Iter(int n) { res= init; while ( fortsett(n) ) { res= Kroppen(n,res); oppdater(n); return res; int Rekursiv(int n) { if (!fortsett(n) ) return basetilfelle / init; else return Kroppen(n, Rekursiv(oppdater(n))); Enhver iterasjon kan skrives som rekursjon... t.o.m. som hale-rekursjon

16 4a. Rekursjon implementeres med en stabel public int fact( int n ) { if (n <= ) return ; else return n * fact( n ); n = fact( ) fact( 3 ) { 6 n = 3 <= NEI 3 * n *? fact( ) { n = <= NEI * n *? n = fact( ) n = 3 fact( 3 ) n *? n = fact( ) n *? n = 3 fact( 3 ) n *? n = 3 fact( 3 ) 6 fact( ) { n = <= JA

17 Method Stack main( ) { int n=5; int z=; 8 int a= aa(z); int aa(int z) { int m=3; 96 bb(...); return 8; 0 void bb(...) { main( ) { int n=5; int z=; int a= aa(z) 8 PC= 0 bb(... ) m = 3 z = PC= 96 aa() m = 3 z = PC= 96 aa() z = z = aa( ) { n = 5 n = 5 PC= 8 PC= 8 z = ; main( ) main( ) int m=3; bb(...) return 8; bb(... ) { a = 8 z = n = 5 PC= 8 main( )

18 Kompleksitet av en rekursiv funksjon avhenger av Analyse vha REKURSJONSTRE størrelsen på steget i hvert rekursivt kall (høyden av treet) antall rekursive kall i hvert steg ( bredden av forgreninger) arbeidsmengden ved sammensetting av resultater fra rekursive kall. Anta dette O() i eksemplene under. R(n) har rekursive kall til R(n-) R(n+) = R(n) + R(n) O( n+ ) R(n) har 3 rekursive kall til R(n-) R(n+) = R(n) + R(n) + R(n) O(3 n+ ) R(n) har rek. kall til R(n-) R(n+) = R(n) + c O(n) h= 3 0 h= 3 0 h= 3 0 R(n) har rek kall til R(n-) og R(n-) R(n+) = R(n+) + R(n) O(.6 n ) h= 3 0 Fibonacci kan dog forenkles til: O(n) R(n) har rek. kall til R(n/) R(n) = R(n/) + R(n/) log(n)+ = n- = O(n) h= 3 for n (n/) (n/4) 0 (n/8) i-0 : H Rekursjon: 8

19 5. Korrekthet Gitt en instans n av et problem P :. hva gjør jeg når n er basis tilfelle. hvordan konstruere løsning for n utfra løsninger for noen instanser mindre enn n P(n) if Basis(n) return??? Terminering: P(n) if Basis(n) stopper rekursjon Korrekthet: P(n) if Basis(n) kontroller korrekt utførelse else return Kombiner(P(m)... P(mk)) else garanter at hver mi < n, er nærmere Basis kombinasjon opprettholder rekursjons-invariant else HER MÅ VI VISE HVIS -> SÅ HVIS hvert rekursivt kall P(mi) returnerer riktig resultat!!! DET OVENSTÅENDE ANTAR VI!!! SÅ gir Kombiner(P(m)... P(mk)) riktig resultat i-0 : H Rekursjon: 9

20 5. Korrekthet Gitt en instans n av et problem P :. hva gjør jeg når n er basis tilfelle. hvordan konstruere løsning for n utfra løsninger for noen instanser mindre enn n sum(n) if n == 0 return 0 else return n + sum(n ) Terminering: sum(n) if n <= stopper rekursjon else hver n < n, er nærmere Basis Korrekthet: sum(n) if n == 0 resultat er 0 : i = 0 i = 0 else HER MÅ VI VISE HVIS -> SÅ HVIS rekursivt kall sum(n ) returnerer riktig resultat!!! DET OVENSTÅENDE ANTAR VI!!! 0 kombinasjon opprettholder sum(n) = n i = 0 i SÅ gir n + sum(n ) riktig resultat : i = n + n i = 0 n i = 0 i

21 Korrekthet: rekursjons-invariant /* int[] QS(int[] A) { int n= A.length; * if (n == ) { return A; * else { * velg pivot p ε A og * del A i : * A= { xεa x p og A = { xεa x > p; * sorter rekursivt (mindre) delene * r= QS(A) og * r= QS(A) * return r + r */ Invariant: QS(A) returnerer sortert argument A: if n== da er A sortert else deler A i to disjunkte deler A= { xεa x p og A = { xεa x > p r= QS(A) returnerer sortert A r= QS(A) returnerer sortert A men da er r+r sortert siden A < A /* int[] MS(int[] A) { int n= A.length; * if (n == ) { return A; * else { * del A i midten i : * A= A[0...n/] og A = A[n/+...n]; * sorter rekursivt (mindre) delene * r= MS(A) og * r= MS(A) * return flettet resultat av * rekursive kall FL(r,r) */ Invariant:... if lgh== da er A... else deler A i to disjunkte deler A= A[0...n/] og A= A[n/+...n] r= MS(A)... r= MS(A)... hvis... så returnerer hele else-grenen sortert A i-0 : H Rekursjon:

22 Korrekthet: rekursjons-invariant /* int BS(int[] A, int x, int l, int h) { * int m= (l+h) / ; * if (l > h) return ; * else if (A[m] == x) return m; * else if (A[m] < x) return BS(A, x, m+, h); * else return BS(A, x, l, m ); */ Invariant: argumentet A er sortert & er x i A, så er den mellom [l... h] (initielt kall med (A, x, 0, A.length-) if l > h x kan ikke være der ( er riktig) else if A[m] = x da har vi funnet den (m er riktig) else if A[m] < x er x i A, så må den være mellom [m+... h] BS(A, x, m+, h) vil returnere riktig resultat else A[m] > x er x i A, så må den være mellom [l... m ] BS(A, x, l, m ) vil returnere riktig resultat

23 Oppsummering. Rekursjon Splitt og hersk bestem hva som må gjøres i basis tilfelle(r) konstruer ( hersk ) en løsning fra (rekursive) løsninger for ( splitt ) noen mindre instanser. Enhver induktiv datatype (nat, int, lister, trær,...) gir opphav til rekursive algoritmer 3. Rekursjon vs. iterasjon (rekursjon implementeres iterativt med bruk av stabel) 4. Korrekthet bestem rekursjons-invarianten verifiser at basistilfelle(r) etablerer invarianten under antakelse at rekursive kall etablerer invarianten, vis at konstruksjonen vil opprettholde den