Inzicht in recursie en recursieve formule

herhaling

Iteratie is herhaling van een proces. Een student die naar school gaat herhaalt het proces van naar school gaan elke dag tot het afstuderen. We gaan minstens een of twee keer per maand naar de supermarkt om producten te kopen. We herhalen dit proces elke maand. In de wiskunde volgt een Fibonacci-reeks ook de eigenschappen van taakherhaling. Laten we de Fibonacci-reeks bekijken waarbij de eerste twee getallen 0 en 1 zijn, alle andere getallen de som van de vorige twee getallen.

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

Iteratiestappen

De Fibonacci-formule kan worden geschreven als:

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

Het onderstaande algoritme levert het n-Fibonacci-nummer op.

Herhaling

Elke keer dat we een nieuw Fibonacci-nummer (n-de getal) krijgen, is dat n-getal feitelijk (n - 1) het getal wanneer we (n + 1) de Fibonacci vinden als onze volgende n-de Fibonacci. Zoals we de hierboven genoemde iteratiestappen zien: als n = 2 dan
fibonacci (2) = fibonacci (2 - 1) + fibonacci (2 - 2) = fibonacci (1) + fibonacci (0) = 1 + 0 = 1

Nu willen we fibonacci (3) genereren, dat is n = 3.

fibonacci (3) = fibonacci (3 - 1) + fibonacci (3 - 2) = fibonacci (2) + fibonacci (1) = 1 + 1 = 2
Dat betekent dat elke keer dat n de waarde van de huidige (n - 1) ste en (n - 2) de fibonacci verhoogt, ook de waarde toeneemt. Maar het is vermoeiend om (n - 1) en (n - 2) de fibonacci voor elke n bij te houden. Hoe zit het met het schrijven van een methode die zichzelf roept om zelf de taak van iteratie te herhalen?

Een methode die zichzelf aanroept, wordt genoemd als recursieve methode. Een recursieve methode moet een basisgeval hebben waarbij het programma zichzelf niet meer noemt. Ons basisscenario voor de Fibonacci-reeks is fibonacci (0) = 0 en fibonacci (1) = 1. Anders noemt de Fibonacci-methode zichzelf tweemaal - fibonacci (n - 1) en fibonacci (n - 2). Vervolgens worden ze toegevoegd om fibonacci (n) te krijgen. Een recursieve methode voor het vinden van nth Fibonacci kan worden geschreven als -

PRO TIP: Als het probleem zich voordoet met uw computer of een laptop / notebook, kunt u proberen de Reimage Plus-software te gebruiken die de opslagplaatsen kan scannen en corrupte en ontbrekende bestanden kan vervangen. Dit werkt in de meeste gevallen, waar het probleem is ontstaan door een systeembeschadiging. U kunt Reimage Plus downloaden door hier te klikken

Als we goed kijken, volgt recursie de eigenschap van stapel. Het lost kleinere subproblemen op om de oplossing van een probleem te krijgen. Voor n> 1 voert het de laatste regel uit. Dus, als n = 6, De functie roept en voegt fibonacci (6 - 1) en fibonacci (6 - 2) toe. fibonacci (6 - 1) of fibonacci (5) roept en voegt fibonacci (5 - 1) en fibonacci toe (5 - 2). Deze recursie gaat door totdat 6 de basiswaarde bereikt die fibonacci (0) = 0 of fibonacci (1) = 1 is. Zodra deze het basisgeval bereikt, telt het twee basiswaarden op en gaat het omhoog totdat het de waarde van fibonacci krijgt ( 6). Hieronder staat een boomrepresentatie van recursie.

recursie Tree

Zoals we kunnen zien, hoe krachtig een recursie kan zijn. Slechts een enkele regel code maakt de boomstructuur hierboven (laatste regel van de bovenstaande code inclusief basishulzen). Recursie behoudt een stapel en gaat dieper naar het basisgeval. Dynamic Programming (DP): Recursie is gemakkelijk te begrijpen en te coderen, maar kan duur zijn in termen van tijd en geheugen. Bekijk de recursieboom hieronder. De linkerboomboom die begint met fib (4) en de rechterboom die begint met fib (4) is precies hetzelfde. Ze genereren hetzelfde resultaat dat 3 is, maar doen dezelfde taak twee keer. Als n een groot getal is (bijvoorbeeld: 500000), kan recursie een programma erg langzaam maken omdat het dezelfde subtaak meerdere keren zou aanroepen.

recursie Door bomen omcirkeld

Om dit probleem te voorkomen, kan dynamisch programmeren worden gebruikt. Bij dynamisch programmeren kunnen we eerder opgeloste subtaken gebruiken om toekomstige taken van hetzelfde type op te lossen. Dit is een manier om de taak voor het oplossen van het oorspronkelijke probleem te verminderen. Laten we een array maken [] waar we eerder opgeloste oplossingen van oplossingen opslaan. We weten al dat fib [0] = 0 en fib [1] = 1. Laten we deze twee waarden opslaan. Wat is de waarde van fib [2]? Aangezien fib [0] = 0 en fib [1] = 1 al zijn opgeslagen, hoeven we alleen maar te zeggen fib [2] = fib [1] + fib [0] en dat is alles. We kunnen fib [3], fib [4], fib [5],, fib [n] op dezelfde manier genereren. Eerder opgeloste subtaken worden opgeroepen om de volgende subtask te krijgen totdat de oorspronkelijke taak niet is opgelost, waardoor overbodige berekening wordt gereduceerd.