Forståelse Rekursion og rekursiv formel

iteration

Iteration er gentagelse af en proces. En studerende, der går i skole, gentager processen med at gå i skole hver dag indtil eksamen. Vi går til købmand mindst en eller to gange om måneden for at købe produkter. Vi gentager denne proces hver måned. I matematik følger en Fibonacci-sekvens også egenskaberne for opgaveåbning. Lad os overveje Fibonacci-sekvensen, hvor de to første tal er 0 og 1, alle andre tal er summen af de to foregående tal.

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

Iteration Steps

Fibonacci-formlen kan skrives 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 nedenfor givne algoritme returnerer nth Fibonacci nummer.

rekursion

Hver gang vi får et nyt Fibonacci nummer (nth nummer), er nth nummer faktisk (n - 1) tallet når vi finder (n + 1) th Fibonacci som vores næste nth Fibonacci. Som vi ser ovenstående iterationstrin: Hvis n = 2 så
fibonacci (2) = fibonacci (2 - 1) + fibonacci (2 - 2) = Fibonacci (1) + Fibonacci (0) = 1 + 0 = 1

Nu ønsker vi at generere fibonacci (3), det vil sige n = 3.

fibonacci (3) = fibonacci (3 - 1) + fibonacci (3 - 2) = Fibonacci (2) + Fibonacci (1) = 1 + 1 = 2
Det betyder, hver gang n øger værdien af nuværende (n - 1) th og (n - 2) th fibonacci øges også. Men det er trættende at holde styr på (n - 1) th og (n - 2) th fibonacci for hver n. Hvad med at skrive en metode, der kalder sig til at gentage opgaven med iteration alene?

En metode, der kalder sig selv, hedder som rekursiv metode. En rekursiv metode skal have en grundlæggende sag, hvor programmet stopper med at kalde sig selv. Vores basiscase til Fibonacci-serien er fibonacci (0) = 0 og fibonacci (1) = 1. Ellers kalder Fibonacci-metoden sig to gange - fibonacci (n - 1) og fibonacci (n - 2). Så tilføjer de dem for at få fibonacci (n). En rekursiv metode til at finde nth Fibonacci kan skrives som -

PRO TIP: Hvis problemet er med din computer eller en bærbar computer / notesbog, skal du prøve at bruge Reimage Plus-softwaren, som kan scanne lagrene og udskifte korrupte og manglende filer. Dette virker i de fleste tilfælde, hvor problemet er opstået på grund af systemkorruption. Du kan downloade Reimage Plus ved at klikke her

Hvis vi ser forsigtigt ud, følger recursion ejendommen til stakken. Det løser mindre delproblemer for at få løsningen af et problem. For n> 1 udfører den den sidste linje. Så, hvis n = 6, kalder funktionen og tilføjer fibonacci (6 - 1) og fibonacci (6 - 2). fibonacci (6 - 1) eller fibonacci (5) kalder og tilføjer fibonacci (5 - 1) og fibonacci (5 - 2). Denne rekursion fortsætter indtil 6 når ned til dens basiscase værdi, som er fibonacci (0) = 0 eller fibonacci (1) = 1. Når den har ramt basissættet, tilføjer den to basisværdier og går op, indtil den får værdien af fibonacci ( 6). Nedenfor er en trærepræsentation af rekursion.

rekursion træ

Som vi kan se, hvor kraftig en rekursion kan være. Kun en enkelt kode kode gør træet ovenfor (sidste linje i koden ovenfor, herunder basissager). Rekursion opretholder en stabel, og den går til dybere, indtil den når basissættet. Dynamisk programmering (DP): Rekursion er let at forstå og kode, men kan være dyrt med hensyn til tid og hukommelse. Tag et kig på rekursionstræet nedenfor. Den venstre undertræ startende med fib (4) og den rigtige undertræ startende med fib (4) er nøjagtigt ens. De genererer det samme resultat, som er 3, men har samme opgave to gange. Hvis n er et stort tal (eksempel: 500000), kan rekursion gøre et program meget langsomt, da det ville kalde samme underopgave flere gange.

recursion Tree-cirklede

For at undgå dette problem kan dynamisk programmering bruges. I dynamisk programmering kan vi bruge tidligere løst underopgave til at løse fremtidige opgaver af samme type. Dette er en måde at reducere opgaven til at løse oprindelige problem. Lad os have et array fib [], hvor vi lagrer tidligere løst subtask løsninger. Vi ved allerede, at fib [0] = 0 og fib [1] = 1. Lad os gemme disse to værdier. Nu, hvad er værdien af fib [2]? Da fib [0] = 0 og fib [1] = 1 er blevet lagret, må vi bare sige fib [2] = fib [1] + fib [0] og det er alt. Vi kan generere fib [3], fib [4], fib [5],, fib [n] på samme måde. Tidligere opløste undertekster bliver kaldt for at få næste underopgave, indtil den oprindelige opgave ikke er løst, hvilket reducerer overflødig beregning.