Programmierung

Fibonacci-Reihenproblem in Java

Inhaltsverzeichnis ausblenden 1 Die ersten Fibonacci-Zahlen sind 0 bzw. 1 2 Drucken Sie Fibonacci-Reihen in Java mit Rekursion ...

Geschrieben von Niel Patel · 5 min gelesen >
Was ist ein Beispiel für eine Fibonacci-Reihe?

Was ist eine Fibonacci-Reihe in Java am Beispiel?
Wie berechnet man Fibonacci in Java?
Was ist ein Beispiel für eine Fibonacci-Reihe?
Wie findet man die Summe der Fibonacci-Reihe in Java?

In diesem Blog werden wir das verstehen Konzept der Fibonacci-Reihe in Java Sprache. Aber bevor wir fortfahren, müssen wir die Fibonacci-Reihe und ihre Eigenschaften verstehen. Die Fibonacci-Reihe in Java ist eine Zahlenreihe, bei der jedes Mitglied durch Addition der beiden vorherigen Mitglieder erhalten wird. Jedes Element der Fibonacci-Reihe wird als Fibonacci-Zahl bezeichnet.

Um dieses Modell zu verstehen, müssen Sie die wesentlichen Java-Programmierthemen wie Fähigkeiten, Kreise, Kontingentproklamationen usw. kennen. Bitte spielen Sie also auf diese Themen an, bevor Sie sich mit der Fibonacci-Reihe in der Java-Ausgabe befassen.

Beispiel: - 0,1,1,2,3,5,8,13,21,34  etc ist ein Beispiel für eine Fibonacci-Reihe

Die ersten Fibonacci-Zahlen sind 0 bzw. 1

F(N) = F(N-1)+F(N-2)

Der obige Ausdruck ist die allgemeine Gleichung, der jede Fibonacci-Zahl folgt. Die obige Gleichung hilft uns auch, die folgenden Fibonacci-Zahlen zu finden.

Als nächstes besprechen wir das Drucken der Fibonacci-Reihe in der Java-Sprache. Es gibt mehrere Möglichkeiten, die Fibonacci-Reihe in Java auszudrucken. Aber wir werden die häufigste Variante im Detail besprechen. Wir werden auch die andere wichtige Methode kurz besprechen. 

  • Drucken Sie Fibonacci-Reihen in Java mithilfe von Rekursion
  • Drucken Sie Fibonacci-Reihen in Java iterativ

Drucken Sie Fibonacci-Reihen in Java mithilfe von Rekursion

Da die Fibonacci-Zahl nichts anderes ist als die Summe der beiden vorherigen Zahlen, können wir die Rekursion mit der folgenden Bedingung verwenden:

  1. Ermitteln Sie, welcher Term der Fibonacci-Reihe berechnet werden muss, z. B. 1., 2., 3. usw.
  2. Rekursive Iteration vom Wert N bis 1:
  • Basisfall: Hier müssen wir zwei Bedingungen angeben, um den Basisfall zu erfüllen, dh wenn n gleich 1 oder n gleich 0 ist, geben Sie n zurück. Da wir gleichzeitig zwei rekursive Aufrufe für fib_2 durchführen, rufen wir fib_1 und auf fib_0. Wenn wir den Basisfall nur angeben, wenn n gleich 1 ist, erhält unser Code einen Rekursionstiefenfehler, da fib_0 den Basisfall nicht erfüllt.
  • Rekursiver Aufruf: Wenn die Basisfallbedingung nicht erfüllt ist, führen wir einen rekursiven Aufruf für die letzten beiden Zahlen durch, d. h. n-1, n-2 als:

rekursive_Funktion(N – 1) + rekursive_Funktion(N – 2);

  • Rückgabeerklärung: Geben Sie bei jedem rekursiven Aufruf die Summe des Fibonacci-Werts der beiden vorherigen Zahlen zurück, die mithilfe der Rekursion ermittelt wurden  

rekursive_Funktion(N – 1) + rekursive_Funktion(N – 2);

Unten sehen wir die Umsetzung des oben genannten Ansatzes:

Code:-

//Scanner importieren

java.util.Scanner importieren;

// Fibonacci-Reihe in Java mit Rekursionsimplementierung

Klasse programming_ninja {

    // Funktion zum Drucken der Fibonacci-Reihe

    öffentliches statisches int fibonacci(int n) {

        // Basisfall

        if (n==1||n==0) {

            gib n zurück;

        }

        // Rekursiver Aufruf

        return fibonacci(n – 1)+ fibonacci(n – 2);

    }

    // Hauptfunktion

    public static void main (String [] args) {

        // Scannerobjekt erstellen 

        Scanner sc = neuer Scanner(System.in);

        // Nimm N Eingaben 

        int N = sc.nextInt();

        // Die ersten N Zahlen ausgeben

        for (int i = 0; i < N; i++) {

            System.out.print(fibonacci(i) + „“,);

        }

    }

}

Ausgabe:-

8

0,1,1,2,3,5,8,13, 

Drucken Sie Fibonacci-Reihen in Java iterativ

Um die Fibonacci-Reihe in Java mithilfe von Iteration zu drucken, müssen wir zunächst die erste und zweite Zahl initialisieren 0 und 1 (Diese beiden Zahlen 1 und 2 stellen die ersten beiden Zahlen der Reihe dar). Anschließend drucken wir die erste und zweite Zahl aus. Danach geben wir den Fluss in die iterative for-Schleife ein. Wir erhalten das nächste Mitglied der Serie, indem wir die beiden vorherigen Mitglieder hinzufügen. Gleichzeitig tauschen wir die erste Zahl mit der zweiten Zahl und die zweite Zahl mit der dritten Zahl.

Code:-

// Scanner importieren

java.util.Scanner importieren;

öffentliche Klasse programming_ninja {

        // Fibonacci-Funktion 

        öffentliche statische Leere Fibonacci(int N) {

        // Initialisierung der ersten beiden Fibonacci-Zahlen

        int num1 = 0, num2 = 1;

        // Zähler initialisieren

        for(int i=0;i

         System.out.print(num1+““,);

         // Tauschen

         int num3 = num2 + num1;

         num1 = num2;

         num2 = num3;

        }

    }

        public static void main (String [] args) {

        // Scannerobjekt erstellen 

        Scanner sc = neuer Scanner(System.in);

        // Nimm N Eingaben 

        int N = sc.nextInt();

        // Rufen Sie die Fibonacci-Funktion auf, um N Fibonacci-Zahlen zu erhalten

        Fibonacci(N);

        // Scanner schließen

        sc.close();

}

Ausgabe:- 

8

0,1,1,2,3,5,8,13, 

Ansatz: (Dynamische Programmierung)

Der dritte Ansatz für das Problem der Fibonacci-Reihe in Java lautet wie folgt.

  • Erstellen Sie ein Array arr1[] der Größe N.
  • Initiieren Sie arr1[0] = 0, arr1[1] = 1.
  • Durchlaufen Sie [2, N] und aktualisieren Sie das folgende Array arr1[] als:
    • arr1[i] = arr1[i – 2] + arr1[i – 1]
  • Gibt den Wert von arr1[N] aus.

Beispiel für Fibonacci-Reihe

Beispiel: Nehmen wir eine Zahl N=7.

Code

// Programm zum Drucken von Fibonacci-Reihen in Java

// Dynamischer Programmieransatz für

// Fibonacci-Reihe

Klasse fabelhaft {

// Funktion zum Finden der N Fibonacci-Reihe

static int fib_series(int n)

{

// Ein Array initialisieren, um Fibonacci-Zahlen zu speichern.

// 1 Extra zur Behandlung von Groß- und Kleinschreibung, n = 0

int fx[] = new int[n + 2];

int i;

// 0. und 1. Zahl von

// Die Reihen sind 0 und 1

fx[0] = 0;

fx[1] = 1;

für (i = 2; i <= n; i++) {

// Addiere die letzten 2 Zahlen

// in die Serie einfügen und speichern

fx[i] = fx[i – 1] + fx[i – 2];

}

// N-te Fibonacci-Zahl

return fx[n];

}

öffentliche statische Leere

main(String args[])

{

// Nummer N bereitstellen

int N = 7;

// Erste 10 Fibonacci-Zahlen drucken

for (int i = 0; i < N; i++)

System.out.print(fib_series(i) + „“);

}

}

Output

0 1 1 2 3 5 8 

Es gibt zahlreiche Möglichkeiten, die n-Fibonacci-Zahlenreihe zu lösen oder zu erhalten. Anders als die oben besprochenen Codes. Wir könnten den obigen Code auf unterschiedliche Weise optimieren, z. B. indem wir eine While-Schleife verwenden, eine Methode zur Berechnung der Fibonacci-Zahl erstellen und vieles mehr. Es könnten jedoch einige effektive oder vielversprechende Ansätze verwendet werden, um die Fibonacci-Reihe in Java zu erhalten.

  • Die erste Methode ist die Verwendung der Rekursion, die wir oben erläutert haben.
  • Die zweite Methode ist die Verwendung der dynamischen Programmierung. Durch die Speicherung der von uns berechneten Fibonacci-Zahlen könnten wiederholte Arbeiten im Code der Rekursionsmethode vermieden werden. 
  • Eine andere Methode, die Fibonacci-Reihe in Java zu erhalten, ist die Verwendung der direkten Formel für den n-ten Term der Fibonacci-Reihe. 

Fn = {[(√5 + 1)/2] ^ n} / √5 

  • Eine weitere Möglichkeit, die n-te Fibonacci-Reihe zu erhalten, ist die Verwendung der Potenz der Matrix {{1, 1}, {1, 0}}: Dieser Ansatz ist eine weitere O(n)-Zeit. Die Lösung für die Methode besteht darin, n-mal zu multiplizieren die Matrix M = {{1,1},{1,0}} auf sich selbst (mit anderen Worten, wir berechnen Potenz(M, n)), dann erhalten wir die (n+1)-te Fibonacci-Zahl als Element in Zeile 0 und Spalte 0, also am Index (0, 0) in der resultierenden Matrix.
  • Der oben diskutierte Ansatz könnte optimiert werden, um in der O(Logn)-Zeitkomplexität zu arbeiten. Wir könnten die zeitliche Komplexität reduzieren, indem wir eine rekursive Multiplikation durchführen, um Potenz(M, n) zu erhalten. 

Fazit

In diesem Artikel haben wir etwas über die Fibonacci-Reihe erfahren. Wir haben mehrere Konzepte dazu besprochen und gelernt, wie man die Fibonacci-Reihe einfach in Java drucken kann. In Java können mehrere Konzepte auf einem anfänglichen und mittleren Niveau erlernt werden, um Fachwissen in Java zu erwerben. Einige Konzepte beinhalten finale Schlüsselwörter in Java, Java-Grundlagen, ups Konzepte usw. 

Kartenspiel

Ist Unity nur für Spiele? 

Niel Patel in Programmierung
  ·   6 min gelesen

Hinterlassen Sie uns einen Kommentar

Translate »