# Fibonacci -Folge rekursiv berechnen



## JavaAnfänger1990 (29. Nov 2016)

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 (29. Nov 2016)

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 (29. Nov 2016)

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 (29. Nov 2016)

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 (29. Nov 2016)

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


----------



## prise1993 (29. Nov 2016)

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

Edit: @Flown war schneller


----------



## JavaAnfänger1990 (29. Nov 2016)

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 (29. Nov 2016)

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


----------



## Guenter123987 (29. Nov 2016)

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 (29. Nov 2016)

@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 (29. Nov 2016)

@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 (29. Nov 2016)

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 (29. Nov 2016)

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


----------



## JavaAnfänger1990 (29. Nov 2016)

Flown hat gesagt.:


> @JavaAnfänger1990
> 
> ```
> import java.util.Arrays;
> ...


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 (29. Nov 2016)

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 (29. Nov 2016)

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 (29. Nov 2016)

@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 (29. Nov 2016)

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


----------



## Xyz1 (29. Nov 2016)

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.


----------

