Förstå rekursion och rekursiv formel

Iteration

Iteration är repetition av en process. En elev som går till skolan upprepar processen att gå till skolan varje dag fram till examen. Vi går till mataffär minst en eller två gånger i månaden för att köpa produkter. Vi upprepar denna process varje månad. I matematik följer en Fibonacci-sekvens också egenskaperna för upprepning av uppgiften. Låt oss överväga Fibonacci-sekvensen där de två första siffrorna är 0 och 1, alla andra tal är summan av de föregående två talen.

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89

Iteration Steg

Fibonacci-formuläret kan skrivas som,

F (n) = F (n - 1) + F (n - 2)
fibonacci (0) = 0
Fibonacci (1) = 1
fibonacci (2) = fibonacci (1) + Fibonacci (0) = 1 + 0 = 1
fibonacci (3) = fibonacci (2) + Fibonacci (1) = 1 + 1 = 2
fibonacci (4) = fibonacci (3) + Fibonacci (2) = 2 + 1 = 3
fibonacci (5) = fibonacci (4) + Fibonacci (3) = 3 + 2 = 5
fibonacci (6) = fibonacci (5) + Fibonacci (4) = 5 + 3 = 8

Den nedan angivna algoritmen returnerar nth Fibonacci-numret.

Rekursion

Varje gång vi får ett nytt Fibonacci nummer (nth nummer) så är nth numret faktiskt (n - 1) talet när vi hittar (n + 1) th Fibonacci som vår nästa nth Fibonacci. Som vi ser ovanstående iterationssteg: om n = 2 då
fibonacci (2) = fibonacci (2 - 1) + Fibonacci (2 - 2) = Fibonacci (1) + Fibonacci (0) = 1 + 0 = 1

Nu vill vi generera fibonacci (3), det vill säga n = 3.

fibonacci (3) = fibonacci (3 - 1) + Fibonacci (3 - 2) = Fibonacci (2) + Fibonacci (1) = 1 + 1 = 2
Det betyder att varje gång n ökar värdet av nuvarande (n - 1) th och (n - 2) f fibonacci ökar också. Men det är tröttsamt att hålla reda på (n - 1) th och (n - 2) th fibonacci för varje n. Vad sägs om att skriva en metod som kallar sig själv för att upprepa iterationens uppgift?

En metod som kallar sig kallas rekursiv metod. En rekursiv metod måste ha ett basfall där programmet slutar ringa sig själv. Vårt basfall för Fibonacci-serien är fibonacci (0) = 0 och fibonacci (1) = 1. Annars kallar Fibonacci-metoden sig två gånger - fibonacci (n - 1) och fibonacci (n - 2). Sedan lägger det till dem för att få fibonacci (n). En rekursiv metod för att hitta nth Fibonacci kan skrivas som -

Om vi ​​tittar noggrant följer rekursionen egenskapen hos stacken. Det löser mindre delproblem för att få lösningen av ett problem. För n> 1, kör den sista raden. Så, om n = 6, samlar funktionen och lägger fibonacci (6 - 1) och fibonacci (6 - 2). fibonacci (6 - 1) eller fibonacci (5) kallar och lägger till fibonacci (5 - 1) och fibonacci (5 - 2). Denna recursion fortsätter tills 6 når ner till sitt basfall värde som är fibonacci (0) = 0 eller fibonacci (1) = 1. När det har träffat basfallet läggs det till två basvärden och går upp tills det blir värdet av fibonacci ( 6). Nedan är en trädrepresentation av rekursion.

Som vi kan se, hur kraftfull en rekursion kan vara. Endast en enda kodkod gör trädet ovan (sista raden i koden ovan inklusive basfall). Recursion upprätthåller en stapel och går djupare tills den når basfodralet. Dynamisk programmering (DP): Recursion är lätt att förstå och koda men kan vara dyrt när det gäller tid och minne. Ta en titt på recursion-trädet nedan. Den vänstra delträdet som börjar med fib (4) och den högra delträdet som börjar med fib (4) är exakt samma. De genererar samma resultat som är 3 men har samma uppgift två gånger. Om n är ett stort antal (exempel: 500000) kan rekursion göra ett program mycket långsamt, eftersom det skulle kalla samma underuppgift flera gånger.

För att undvika detta problem kan dynamisk programmering användas. I dynamisk programmering kan vi använda tidigare löst underuppgift för att lösa framtida uppgift av samma typ. Detta är ett sätt att minska uppgiften för att lösa det ursprungliga problemet. Låt oss ha en array fib [] där vi lagrar tidigare lösade subtasklösningar. Vi vet redan att fib [0] = 0 och fib [1] = 1. Låt oss lagra dessa två värden. Nu, vad är värdet av fib [2]? Eftersom fib [0] = 0 och fib [1] = 1 har lagrats, måste vi bara säga fib [2] = fib [1] + fib [0] och det är allt. Vi kan generera fib [3], fib [4], fib [5],, fib [n] på samma sätt. Tidigare upplysta subtaskar kallas för att få nästa deluppgift tills den ursprungliga uppgiften inte har lösts, vilket reducerar redundant beräkning.

PRO TIPS: Om problemet är med din dator eller en bärbar dator, bör du försöka använda Reimage Plus-programvaran som kan skanna förvaret och ersätta korrupta och saknade filer. Detta fungerar i de flesta fall där problemet uppstått på grund av systemkorruption. Du kan ladda ner Reimage Plus genom att klicka här