Rekursion Rekursion Rekursion, implementation i Java Rekursiva ...

Rekursion
Rekursion är ett grundläggande begrepp inom matematik och
datavetenskap och används för att göra definitioner och
konstruera algoritmer. Exempel:
Potensfunktionen
x 0 = 1
x n =x * x n–1 , n heltal >0
(Basfall)
(Rekursiva steget)
Fakultetsfunktionen
0! = 1 (Basfall)
n! = n * (n–1)!, n heltal > 0 (Rekursiva steget)
Rekursion
• Dela upp problemet i delproblem (instanser) som har
samma struktur som ursprungliga problemet men är
mindre till sin omfattning (rekursiva steget).
Ex: n! = n * (n–1)!
• Fortsätt uppdelningen tills du fått ett problem som är
trivialt att lösa (basfall).
Ex: 0!
AD, Rekursion 1
AD, Rekursion 2
Rekursion, implementation i Java
/** Beräkna n! */
public long fac(int n) {
if (n==0) {
return 1;
} else {
return n*fac(n-1);
}
}
Rekursiva metoder
En rekursiv metod måste ha
• En eller flera parametrar som bestämmer problemets
storlek
• Ett eller flera basfall som löses direkt.
• Ett eller flera rekursiva anrop. Det rekursiva anropet måste
leda till att ett basfall så småningom nås.
Lita på att det rekursiva anropet ger rätt resultat!
AD, Rekursion 3
AD, Rekursion 4

Rekursion, exempel ur boken (7.3.1)
Problem: Antag att Javas System.out.print(...) enbart klarar
av att skriva ut tecken (char) och strängar. Implementera en
metod för utskrift av ett godtyckligt icke-negativt tal.
Idé: Ett n siffrigt tal t = s 1 s 2 ....s n-1 s n kan delas upp enligt
s 1 s 2 ....s n-1
t/10
s n
t%10
Rekursion, exempel ur boken (7.3.1)
Vi kan enkelt skriva en hjälpmetod som skriver ut ett
ensiffrigt tal:
/** Skriv ut det ensiffriga talet d */
private void printDigit(int d) {
char ch = (char) ('0' + d);
System.out.print(ch);
}
OBS: denna metod är osäker. Ingen kontroll av att talet är
ensiffrigt!
AD, Rekursion 5
AD, Rekursion 6
Rekursion, exempel ur boken (7.3.1)
Lösningen för ett godtyckligt tal ÿ 0 kan nu implementeras
rekursivt enligt:
public void printNumber(int n) {
if (n=10) {
printNumber(n/10);
}
printDigit(n%10);
}
Även här anropas printDigit enbart för ensiffriga tal.
OBS att här anropas printDigit enbart för ensiffriga tal!
AD, Rekursion 7
AD, Rekursion 8

Exekvering av rekursiva metoder
Anrop: printNumber(123)
n=123
n>=10
printNumber(12)
printDigit(3)
n=12
n>=10
printNumber(1)
printDigit(2)
Gäller för alla metodanrop (inte enbart rekursiva):
Ett anrop av en metod skapar en ”aktiveringspost” med plats för
parametrar, återhoppsadress m.m.
När en metod når sitt slut sker återhopp till satsen närmast efter
den där den avslutade upplagan anropades.
n=1
n=base) {
printIntRec(n/base,base);
}
printDigit(n%base); AD, Rekursion 11
}
Rekursion, exempel ur boken (7.3.1)
printIntRec är inte en robust implementation:
• Anrop med base>16 ger ”index out of range”
• Anrop med base=0 ger exekveringsfel pga
division med 0
• Anrop med base=1 ger upphov till en oändlig
kedja av rekursiva anrop pga att det rekursiva
anropet printInt(n/base,base) har sin
första parameter = n
AD, Rekursion 12

Rekursion, exempel ur boken (7.3.1)
Bättre lösning. Robust. Kollar bara en gång att base har rimligt värde genom att
ha en speciell "driver"-rutin. Klarar nu dessutom även negativa tal:
public void printInt(int n, int base) {
if (basedigitTable.length()) {
throw new RuntimeException();
} else {
if (n

Ex: Skriva ut lista baklänges
Element i listan:
class ListNode {
char ch;
ListNode next;
}
Lösning:
public void reverseList( ListNode list) {
if (list!=null) {
reverseList(list.next);
System.out.print(list.ch);
}
}
(Här har vi valt basfallet = tom lista då ingenting skall skrivas.)
AD, Rekursion 17
Hanois torn
1
2
3
4
5
pinne 1 pinne 2 pinne 3
n skivor finns i avtagande storlek på en pinne (1). Flytta
dem så att de kommer i samma inbördes ordning på en
av de andra pinnarna (t ex 3). Även den tredje pinnen
(2) får utnyttjas för mellanlagring.
AD, Rekursion 18
Regler:
Hanois torn
• Bara en skiva i taget får flyttas
• En skiva som tas från en pinne måste genast läggas på en
av de andra pinnarna
• Det får aldrig inträffa under flyttningarnas gång att en
större skiva hamnar ovanför en mindre (på samma pinne).
AD, Rekursion 19
Hanois torn, rekursiv lösning
Flytta först de n-1 översta under iakttagande av alla regler till pinne 2 (3
kan utnyttjas för mellanlagring).
Flytta därefter den största skivan från 1 till 3.
Till sist flyttas de n-1 skivorna från 2 till 3, igen under iakttagande av alla
regler (och med 1 som plats för mellanlagring)
1
2
3
4
5
pinne 1 pinne 2 pinne 3
AD, Rekursion 20

Hanois torn, rekursiv lösning i Java
Hanois torn, rekursiv lösning i Java
Följande metod skriver ut hur man skall flytta:
public void move(int n, int start, int finish, int temp) {
if (n==1) {
System.out.println("Move from "+start+" to "+finish);
} else {
move(n-1, start, temp, finish);
System.out.println("Move from "+start+” to "+finish);
move(n-1, temp, finish, start);
}
}
Anrop:
move(2,1,3,2)
...
move(1,1,2,3)
"Move from 1 to 3"
move(1,2,3,1)
"Move from 1 to 2”
"Move from 2 to 3"
AD, Rekursion 21
AD, Rekursion 22
Samband mellan rekursion och induktion
Matematisk induktion används ofta för att bevisa samband
som gäller för positiva heltal n. Bevisen görs i två steg:
1. Visa att sambandet gäller för ett eller flera små värden
på n.
2. Visa att om man gör antagandet att sambandet håller
för alla heltal n upp till ett visst värde k, så gäller det
även för närmast större värde k+1.
Samband mellan rekursion och induktion
Ex: Visa att 1+2+3+... + n = n(n+1)/2 för alla nÿ1
• n = 1.
Vänsterledet = 1.
Högerledet = 1*2/2=1. Stämmer.
• Vi antar nu att 1+2+....+ n = n(n+1)/2 för 1 n k (*)
Visa att 1+2+...+ k+k+1= (k+1)(k+2)/2.
Vänsterledet = (1+2+...+k) + k+1 = [enligt (*)] =
k(k+1)/2 + k+1= (k 2 +3k+2)/2
Högerledet = (k+1)(k+2)/2 = (k 2 +3k + 2)/2 = Vänsterledet.
AD, Rekursion 23
AD, Rekursion 24

Samband mellan rekursion och induktion
Rekursiva algoritmer kan bevisas ge korrekt resultat
med induktionsbevis.
Ex: Fakultetsberäkningen
public int fac(int n) {
if (n==0) {
return 1;
} else {
return n*fac(n-1);
}
}
Samband mellan rekursion och induktion
1. När n=0 blir resultatet 1 vilket är korrekt enligt def av n!
2. Antag att algoritmen ger korrekt resultat för 0 n k. (*)
Visa att den då också ger korrekt reultat för n=k+1.
Anrop fac(k+1) ger (eftersom k+1>0) resultatet
(k+1)*fac(k+1-1) = (k+1)*fac(k).
Enligt induktionsantagandet (*) ger anropet fac(k) korrekt
resultat dvs k!. Vi får därför resultatet (k+1)*k! = (k+1)!
V.S.B.
AD, Rekursion 25
AD, Rekursion 26
Analys av rekursiva algoritmer, ex;
fakultetsberäkningen
public int fac(int n) {
if (n == 0) {
return 1;
} else {
return n*fac(n–1);
}
}
Sätt T(n) = tidskomplexiteten för ett anrop av fac(n) (*)
AD, Rekursion 27
Analys av rekursiva algoritmer, ex;
fakultetsberäkningen
För n=0 utförs ett arbete som tar konstant tid, c1 (kontroll
n==0 samt return-satsen). Alltså blir T(0) = c1
För nÿ1 utförs dels ett konstant arbete, c2 (kontroll n==0 som
misslyckas, en multiplikation samt en return-sats) dels det
arbete som görs vid ett anrop av fac(n-1). Det senare är
T(n–1) enligt vår ansats (*)
Vi får ett rekursivt uttryck på tidskomplexiteten (rekursionsformel):
T(0) = c1
T(n) = c2 + T(n–1) för nÿ1
AD, Rekursion 28

Analys av rekursiva algoritmer, ex;
fakultetsberäkningen
Rekursionsformeln kan lösas med återsubstitution, dvs man
använder formeln för n, n–1,....0:
T(n) = c2+T(n–1) = c2+c2+T(n–2) = c2+c2+c2+T(n–3) = ...=
i*c2+T(n–i) = ... = n*c2+T(0) = n*c2 + c1 = O(n)
Om vi bara är intresserade av storleksordningen kan vi ersätta c1
ochc2med1:
T(0) = 1
T(n) = 1 + T(n–1) för nÿ1
==> T(n) = 1+T(n–1) = 1+1+T(n–2) = ... = i+T(n–i) = ...
=n+T(0)=n+1=O(n)
AD, Rekursion 29
Binärsökning
Algoritm för att söka i en sorterad vektor
Jämför det sökta med mittelementet i vektorn.
Om likhet, avbryt.
Om det sökta är mindre än mittelementet, fortsätt
sökningen i vänster halva av vektorn
Om det sökta är större än mittelementet, fortsätt
sökningen i höger halva av vektorn
/** Undersök om x finns i den sorterade vektorn a */
public boolean binarySearch(int[] a, int x) {
return binarySearch(a,x,0,a.length–1);
}
AD, Rekursion 30
Binärsökning
/* Privat hjälpmetod. Söker i delvektorn a[low]..a[high] */
private boolean binarySearch(int[] a, int x,
int low, int high) {
if (low>high) {
return false;
} else {
int mid = (low+high)/2; // heltalsdivision!
if (x == a[mid]) {
return true;
} else if (x a[mid]
W(0) = 1
AD, Rekursion 32

Analys av rekursiva algoritmer, ex:
binärsökning
Förenklande antagande: n = 2 k – 1 för något heltal k>0. Då
går alla halveringar jämnt upp.
Då blir mid = (0 + 2 k –1–1)/2=2 k-1 – 1 och därmed
Storleken av vänster halva = mid = 2 k-1 –1och
Storleken av höger halva = n-mid-1 = 2 k –1 –2 k-1 +1–1=
2 k-1 –1.
Rekursionsformeln för tidskomplexiteten blir därför:
W(2 k –1)=1+W(2 k-1 –1) omxa[mid]
Analys av rekursiva algoritmer, ex:
binärsökning
W(2 k –1)=1+W(2 k-1 –1) omk>0
W(0) = 1
Återsubstitution ger:
W(2 k –1)=1+W(2 k-1 –1) =1+1+W(2 k-2 – 1) = ...
1+1+1+W(2 k-3 – 1) = ... = i + W(2 k-i –1)=...(fortsätttillsi
=k) ...=k+W(0)=k+1
Eftersom antagandet var att n = 2 k – 1 så följer att k = 2 log (n+1)
Därmed W(n) = 2 log (n+1) + 1 = O(log n)
W(0) = 1
AD, Rekursion 33
AD, Rekursion 34
Analys av rekursiva algoritmer, ex:
binärsökning
Enklare hade vi kunnat resonera så här för värstafallsanalysen:
Värsta fallet är att testet x == a[mid] misslyckas varje gång.
Halveringarna kommer då utföras ända tills basfallet (tom delvektor) inträffar.
Hur många halveringar kan det högst bli?
Vi har från början en vektor av storlek n. Efter en halvering är storleken n/2,
efter 2 halveringar är den n/4 och efter k halveringar
n/2 k . När vi kommit ner till vektorstorlek 1 ger nästa halvering storlek 0.
Hur många halveringar krävs då för att nå vektorstorlek 1?
Sätt n/2 k =1=>k=logn.
I varje upplaga av rekursionen utförs ett konstant arbete = O(1).
I värsta fall blir det alltså O(1)*log n = O(log n)
AD, Rekursion 35
Söndra och härska (divide and conquer)
Teknik för konstruktion av rekursiva algoritmer.
Söndra: Mindre delproblem (två eller flera) löses
rekursivt (utom basfallen).
Härska: Lösningen till det ursprungliga problemet
konstrueras med hjälp av lösningarna till
delproblemen.
Söndra- och härska-algoritmer leder till rekursiva metoder
som gör minst två rekursiva anrop.
• Är ibland en framkomlig väg när det är svårt att
konstruera iterativ algoritm
• Leder ibland till effektivare algoritm i fall där även
iterativ algoritm finns
AD, Rekursion 36

Söndra och härska, ex
Problem: sortera en vektor a med n tal.
Söndra och härska teknik:
1. Dela vektorn i två lika stora halvor
2. Sortera (rekursivt) första halvan a[0..n/2]
Söndra!
Sortera (rekursivt) andra halvan a[n/2+1..n-1]
3. Slå samman de båda sorterade delvektorerna så att
Härska!
hela vektorn a[0..n–1] blir sorterad
Det är i härska-steget som själva algoritmkonstruktionen ligger.
Söndra-stegen är bara rekursiva anrop.
I detta fall visar det sig vara enkelt att hitta en (linjär) metod för steg 3.
Sorteringsmetoden, som kallas Mergesort, blir mycket effektiv.
Vi återkommer med detaljer senare i kursen.
AD, Rekursion 37
Söndra och härska, ex: Fibonaccitalen
Söndra- och härska-algoritmer är rekursiva algoritmer i
vilka man (utom i basfallen) gör minst två rekursiva
anrop för mindre instanser av samma problem. Detta kan
ibland (men inte alltid!) ge upphov till ineffektivitet. Man
kan komma att beräkna lösningen till samma delproblem
många gånger.
Ex: Fibonaccitalen definieras
F n =F n-1 +F n-2 för nÿ2
F 0 =0
F 1 =1
AD, Rekursion 38
Söndra och härska, ex: Fibonaccitalen
Javametod direkt enligt definitionen:
public long fib(int n) {
if (n

Dynamisk programmering
Dynamisk programmering (i samband med implementation
av rekursiva algoritmer) innebär att man i en tabell
håller reda på vilka instanser av problemet man redan löst.
Varje gång man behöver lösningen till en viss instans
kontrollerar man först i tabellen om den redan beräknats. I
så fall hämtas lösningen där, dvs man gör inget rekursivt
anrop. Om lösningen inte finns i tabellen gör man ett
rekursivt anrop och sätter sedan in den beräknade
lösningen i tabellen.
AD, Rekursion 41
Dynamisk programmering, ex:
Fibonaccitalen
public long fib(int n) {
long[] table = new long[n+1]; //skapa en tabell
for (int i=0; i