Rekursion und rekursive Formel verstehen

Iteration

Iteration ist die Wiederholung eines Prozesses. Ein Schüler, der zur Schule geht, wiederholt den Prozess, jeden Tag bis zum Abschluss in die Schule zu gehen. Wir gehen mindestens ein- oder zweimal im Monat zum Lebensmittelgeschäft, um Produkte zu kaufen. Wir wiederholen diesen Prozess jeden Monat. In der Mathematik folgt eine Fibonacci-Sequenz den Eigenschaften der Aufgabenrepetierung. Betrachten wir die Fibonacci-Folge, in der die ersten beiden Zahlen 0 und 1 sind, alle anderen Zahlen sind die Summe der beiden vorherigen Zahlen.

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

Iterationsschritte

Die Fibonacci-Formel kann wie folgt geschrieben werden:

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

Der unten angegebene Algorithmus gibt die n-te Fibonacci-Zahl zurück.

Rekursion

Jedes Mal, wenn wir eine neue Fibonacci-Zahl (n-te Zahl) erhalten, ist die n-te Zahl tatsächlich (n - 1) -te Zahl, wenn wir (n + 1) -te Fibonacci als unsere nächste n-te Fibonacci finden. Wie wir die oben erwähnten Iterationsschritte sehen: wenn n = 2 dann
Fibonacci (2) = Fibonacci (2 - 1) + Fibonacci (2 - 2) = Fibonacci (1) + Fibonacci (0) = 1 + 0 = 1

Nun wollen wir Fibonacci (3) erzeugen, das ist n = 3.

Fibonacci (3) = Fibonacci (3 - 1) + Fibonacci (3 - 2) = Fibonacci (2) + Fibonacci (1) = 1 + 1 = 2
Das heißt, jedes Mal, wenn n steigt, steigt auch der Wert von Strom (n - 1) und (n - 2) -ten Fibonacci. Aber es ist ermüdend, für jedes n den (n - 1) ten und (n - 2) ten Fibonacci zu verfolgen. Wie wäre es mit dem Schreiben einer Methode, die sich selbst dazu aufruft, die Iterationsaufgabe selbst zu wiederholen?

Eine Methode, die sich selbst aufruft, wird als rekursive Methode bezeichnet. Eine rekursive Methode muss einen Basisfall haben, in dem das Programm nicht mehr selbst aufruft. Unser Basisfall für die Fibonacci-Reihe ist Fibonacci (0) = 0 und Fibonacci (1) = 1. Sonst nennt sich die Fibonacci-Methode zweimal - Fibonacci (n - 1) und Fibonacci (n - 2). Dann fügt er sie hinzu, um Fibonacci (n) zu erhalten. Eine rekursive Methode zum Finden von n-ten Fibonacci kann geschrieben werden als -

Wenn wir genau hinschauen, folgt die Rekursion der Eigenschaft von stack. Es löst kleinere Teilprobleme, um die Lösung eines Problems zu erhalten. Für n> 1 wird die letzte Zeile ausgeführt. Also, wenn n = 6 ist, ruft die Funktion auf und fügt Fibonacci (6 - 1) und Fibonacci (6 - 2) hinzu. Fibonacci (6 - 1) oder Fibonacci (5) nennt und fügt Fibonacci (5 - 1) und Fibonacci (5 - 2) hinzu. Diese Rekursion wird fortgesetzt, bis 6 bis zu ihrem Basisfallwert reicht, der fibonacci (0) = 0 oder fibonacci (1) = 1 ist. Sobald es den Basisfall trifft, addiert es zwei Basiswerte und geht hoch, bis es den Wert von Fibonacci ( 6). Unten ist eine Baumdarstellung der Rekursion.

Wie wir sehen können, wie mächtig eine Rekursion sein kann. Nur eine einzige Codezeile macht den Baum oben (letzte Zeile des obigen Codes einschließlich der Basisfälle). Die Rekursion behält einen Stapel bei und geht tiefer, bis sie den Basisfall erreicht. Dynamische Programmierung (DP): Rekursion ist leicht zu verstehen und zu programmieren, könnte aber in Bezug auf Zeit und Speicher teuer sein. Sehen Sie sich den Rekursionsbaum unten an. Der linke Teilbaum, der mit fib (4) beginnt, und der rechte Teilbaum, der mit fib (4) beginnt, sind genau gleich. Sie erzeugen das gleiche Ergebnis, das 3 ist, machen aber dieselbe Aufgabe zweimal. Wenn n eine große Zahl ist (Beispiel: 500000), kann die Rekursion ein Programm sehr langsam machen, da es dieselbe Unteraufgabe mehrmals aufrufen würde.

Um dieses Problem zu vermeiden, kann die dynamische Programmierung verwendet werden. In der dynamischen Programmierung können wir die zuvor gelöste Teilaufgabe verwenden, um zukünftige Aufgaben desselben Typs zu lösen. Dies ist eine Möglichkeit, die Aufgabe zur Lösung des ursprünglichen Problems zu reduzieren. Lassen Sie uns ein Array fib [] haben, in dem wir zuvor gelöste Subtask-Lösungen speichern. Wir wissen bereits, dass fib [0] = 0 und fib [1] = 1 sind. Speichern wir diese beiden Werte. Nun, was ist der Wert von fib [2]? Da fib [0] = 0 und fib [1] = 1 bereits gespeichert wurden, müssen wir nur noch fib [2] = fib [1] + fib [0] sagen und das ist alles. Wir können fib [3], fib [4], fib [5], fib [n] auf die gleiche Weise erzeugen. Zuvor gelöste Teilaufgaben werden aufgerufen, um die nächste Teilaufgabe zu erhalten, bis die ursprüngliche Aufgabe nicht gelöst wurde, wodurch redundante Berechnungen reduziert werden.

PRO TIPP: Wenn das Problem bei Ihrem Computer oder Laptop / Notebook auftritt, sollten Sie versuchen, die Reimage Plus Software zu verwenden, die die Repositories durchsuchen und beschädigte und fehlende Dateien ersetzen kann. Dies funktioniert in den meisten Fällen, in denen das Problem aufgrund einer Systembeschädigung auftritt. Sie können Reimage Plus herunterladen, indem Sie hier klicken