Fibonacci -Folge rekursiv berechnen

[JavaAnfänger1990]

Moin Leute,
da bin ich wieder mit einem neuen Problem. Habe im Forum nachgeschaut aber keinen passenden Ansatz gefunden.
Ich habe die Aufgabe eine Fibonacci-Folge durch rekursive Methodenaufrufe zu berechnen. Rekursive Berechnung der Fibonacci-Folge dieser Form kann ich nachvollziehen.

public class Fibonacci{

   public static int fibonacci(int n){
       if(n ==1){
           return1;
       }else{
           return(fibonacci(n-1)+ fibonacci(n-2));
       }
       
   }

Aber bei meiner Aufgabe hat die Fibonacci-Methode den Typ integer-array, nämlich so.

public class Fibo{
    public static void main(String[] args){
           int[] array={1,1,0,0,0,0}
    
    }
    public static int[] fibonacci(int[] a, int n){
          int[] a = new int[array.length-n];   // Erzeugen eines Hilfsarrays 
          
          for(int i=n; i<array.length;i++){
          int fn= (array[i]-2)-(array[i]1);      //Fibonacci Formel, der Int-Variable fn wird der                                                                        //berechnete Wert zugewiesen

          a[i]= fib(array,2)+fib(array-1);    /*Hier komme ich leider nicht weiter wegen des                                                                       rekursiven Methodenaufrufs, aber vor allem wegen                                                                 der Rückgabe- Argumententypen der Methode                                                                          int[] fibonacci(int[]a, int n)
        }
        return a;
    }

Das heißt, die Länge des Arrays ist bekannt. Ich initialisiere die ersten 2 Arraywerte und möchte ihm sagen, bitte ab array[2] die Werte ausgeben und ins array speichern.
Mein Ansatz: eine for-Schleife zur Berechnung aller Werte bis array.length.

Ich bitte euch nur um Tipps, wie man in dieser Art die Fibonacci berechnen kann und bedanke mich herzlich.

 

[prise1993]

Ich würde eine Methode

 fiboRek(int n)

schreiben die dir die nte Fibonaccizahl zurück gibt!
Und mit Hilfe dieser Methode das Array befüllen!
Also das du es in der for-Schleife mit a = fiboRek(i); befüllst!
Muss das Array rekursiv befüllt werden?

 

[Joose]

Diese Probem hatten wir letztens erst
Hier der Link zum Thread: http://www.java-forum.org/thema/fibonacci-in-array-mit-rekursiver-methoden.175416/

 

[Guenter123987]

Ich weiß nicht, was rekursiv ist, habe aber schon eine Fibonaccimethode geschrieben.

public static int Fibonacci(int n) {
     int ergebnis = 0;
     for (int i = 0; i <= n; i++) {
       ergebnis += i;
     }
     return ergebnis;
   }

 

[Flown]

@Guenter123987 Du hast soeben die Summ von 0-n gepostet und nicht die Fibonaccifolge: HIER mein Tutorial über Rekursion

 

[prise1993]

Das macht aber keine fibonacci zahlen du summiertst nur bis n auf !

Edit: @Flown war schneller

 

[JavaAnfänger1990]

Danke Joose für den Link. Ich habe es anderweitig erledigt. Ich poste mal die Lösung, damit der Thread geschlossen werden kann.

    public static int[] fibonacci(int[] a, int n){
       
        for(int i=n; i<a.length;i++){                
           
        array[n]=(a[n-1])+(a[n-2]);        
            fibonacci(a,n+1);                             
           
        }
        return array;
    }

 

[Flown]

@JavaAnfänger1990 Dein Code ist falsch! Ich würde dir auch mal mein Tutorial über Rekursion ans Herz legen.

 

[Guenter123987]

So sind auch die Zwischenwerte drinnen, also die Fibonaccifolge bis zu n. Ist halt ein Integer - Array und kein int - Array, der zurückgegeben wird.

public static Integer[] Fibonacci(int n) {
   ArrayList<Integer> Fibonaccizahlen = new ArrayList<Integer>();
   int ergebnis = 0;
   for (int i = 0; i <= n; i++) {
     ergebnis += i;
     Fibonaccizahlen.add(ergebnis);
   }
   Integer[] fibonaccizahlen = (Integer[]) Fibonaccizahlen.toArray();
   return fibonaccizahlen;
}

 

[Flown]

@Guenter123987 Das ist keine Fibonaccifolge. Warum postest du sowas überhaupt?
Geschweige davon, dass die Zeile:

Integer[] fibonaccizahlen = (Integer[]) Fibonaccizahlen.toArray();

eine ClassCastException wirft.

Unterlasse doch einfach diese Posts, wenn du es nicht besser weißt.

 

[Flown]

@JavaAnfänger1990 Hier mal wies gemacht wird und lass dich bitte nicht verwirren:

import java.util.Arrays;

public class Test {
  public static void main(String... args) {
    System.out.println(Arrays.toString(fibonacci(10)));
  }
  
  public static int[] fibonacci(int n) {
    return fibonacci(new int[n], 0);
  }
  
  private static int[] fibonacci(int[] a, int i) {
    if (i >= a.length) {
      return a;
    }
    a[i] = i == 0 || i == 1 ? 1 : a[i - 2] + a[i - 1];
    return fibonacci(a, i + 1);
  }
}

 

[JavaAnfänger1990]

Danke Flown. Ich werde mir auf jeden Fall deine Tutorials angucken. Mein Code ist im vorgegebenen Rahmen richtig (Die Aufgabenstellung ist der Link von Joose). Erst dann funktioniert es richtig, wenn man die vorgegebene main-Methode miteinbezieht.
Danke Leute

 

[Flown]

@JavaAnfänger1990 Naja das ist jetzt eine Sache die du selbst umschreiben kannst (TIPP: einfach die private Methode verwenden).

 

[JavaAnfänger1990]

@JavaAnfänger1990

import java.util.Arrays;

public class Test {
  public static void main(String... args) {
    System.out.println(Arrays.toString(fibonacci(10)));
  }
 
  public static int[] fibonacci(int n) {                    //Methode zur Erzeugen eines Array
    return fibonacci(new int[n], 0);                       // Rückgabe der rekursiven Methode vom Rückgabetyp                                                                           //Integer
  }
 
  private static int[] fibonacci(int[] a, int i) {
    if (i >= a.length) {                                          // Überprüfen der Bediengung, 
                                                                          //ob Laufvariable i > Länge des Array
      return a;                                                       // Wenn Bedingung erfüllt ist, Rückgabe des Array a                                                                               //aber Warum, welche Werte hat denn das Array a
    }
    a[i] = i == 0 || i == 1 ? 1 : a[i - 2] + a[i - 1];  //wenn a[i]==0 oder 1 |Dann 1: Berechnung der Fib.-                                                                            //Zahl
    return fibonacci(a, i + 1);                                 // Rückgabe der rekurs. Methode, Stelle wird um 1                                                                                  //erhöht
  }
}

Ich habe Probleme beim Nachvollziehen der Vorgehensweise. Ich würde gerne deinen Code kommentieren und dich darum bitten, mir mitzuteilen, ob ich es richtig verstanden habe.

 

[Flown]

Naja du hast das ja schon richtig durchschaut... Aber was glaubst du denn was das Array a für einen Wert hat? Natürlich den, den du mitgegeben hast, oder was verstehst du dabei nicht?

EDIT: Wenn du mein Tutorial ansiehst, dann wirst du auch sehen, dass die erste if-Abfrage die wichtigste ist, denn sie ist die Rekursionsabbruchbedingung.

 

[Guenter123987]

Die Fibonaccifolge ist doch 1, 3, 6, 10, 15, 21 usw.
Dann müssten diese 2 Methoden ausreichen.

public static int fibonacciOfIndex(int index) {
   int fibonacci = 0;
   for(int i = 1; i <= index; i++) {
     fibonacci += i;
   }
   return fibonacci;
}

public static int[] fibonacciUpToIndex(int index) {
   int[] fibonacciArray = new int[index];
   for(int i = 1; i <= index; i++) {
     fibonacciArray[i-1] = fibonacciOfIndex(i);
   }
   return fibonacciArray;
}

 

[Flown]

@Guenter123987 Warum? Du bist im Internet, warum schaust du nicht selbst nach, was die Fibonaccifolge ist? Z.B.: WIKIPEDIA
Die Folge ist 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...

 

[JavaAnfänger1990]

Danke Flown, ich habe es jetzt gecheckt, nachdem ich mir dein Tutorial angeschaut habe.

 

[Xyz1]

Diese Frage hatten wir doch eben erst: http://www.java-forum.org/thema/negafibonacci-folge-berechnen.175321/

n < 0 kannst du einfach rausschmeißen, und das mit 1 auch.

Mal im Ernst, wir dürfen diese ganzen Heimübungen nicht für euch berechnen. Ich habe schon einen aufs Dach bekommen deswegen.