Kann mir jemand bei der Fibonacci Reihe in Java helfen?
Kann mir vill jemand weiterhelfen, ich möchte die fibonacci Reihe bis n = 10 einmal Iterativ und einmal Rekursiv ausgeben.
Kann mir vill jemand helfen wo meine Fehler in meinem Programm liegen?
3 Antworten
Eigentlich müsste dir das Programm schon eine Fehlermeldung ausgeben. Der hauptsächliche Knackpunkt ist der Code in der fib-Funktion.
if (pos == 1)
return array[0] = 1;
/*
* Es wird zwar übersichtshalber normalerweise vermieden,
* aber der Zuweisungs-Operator (=) gibt auch den Wert zurück,
* den er zugewiesen hat, in diesem Fall also die 1.
* Die 1 ist aber ein einfaches int und kein int-Array.
* Die Positionen 0 und 1 hast du aber schon vorgefüllt,
* daher kannst du hier einfach das Array zurückgeben
*/
else
return array[pos - 1] = fib(array, pos - 1) + fib(array, pos - 2);
/*
* Mir ist ehrlichgesagt nicht ganz klar, was du hier versuchst.
* Zwei Arrays kannst du nicht mit + verbinden. Und selbst wenn
* das gehen würde, könntest du das Ergebnis nicht in ein Feld
* eines int-Arrays schreiben. Abgesehen davon hast du hier den
* gleichen Fehler, wie in der oberen Bedingung.
*/
Dazu kommt noch, dass du die fib-Funktion in der main mit der position 2 aufrufst und dann in der fib-Funktion versuchst, immer weiter nach links zu wandern. Es würde also selbst wenn sonst alles richtig wäre, nur die dritte Position im Array gefüllt werden.
Außerdem natürlich noch das, was die anderen sagen: Du sollst (ziemlich wahrscheinlich) nicht nur die reine Ausgabe getrennt nach iterativ und rekursiv machen, sondern das Array einmal interativ und einmal rekursiv füllen.
Das ist zwar eigentlich keine passende Aufgabe, die man normalerweise rekursiv lösen würde, aber es geht trotzdem.
import java.util.Arrays;
public class Fibonacci {
public static void main(String[] args) {
printIterativ();
printRekursiv();
}
public static void printIterativ() {
// neues Array erstellen
int[] result = new int[10];
// Die ersten beiden Felder auf 1 setzen
result[0] = 1;
result[1] = 1;
// Alle weiteren Felder mit der Summe aus den
// beiden vorherigen Feldern füllen
for (int i = 2; i < 10; i++) {
result[i] = result[i-1] + result[i-2];
}
// Array ausgeben
System.out.println(Arrays.toString(result));
}
public static void printRekursiv() {
// Ergebnis der rekursiven Befüllung ausgeben
System.out.println(Arrays.toString(fibRekursiv(9)));
}
private static int[] fibRekursiv(int pos) {
// falls die zweite Zelle abgefragt wird, die ersten beiden Zellen zurückgeben
if (pos == 1) {
return new int[] {1, 1};
} else {
// Ansonsten ein Array von der passenden Größe erstellen,
// damit die aktuelle Position reinpasst,
// mit den Daten der vorherigen Position füllen
int[] result = Arrays.copyOf(fibRekursiv(pos - 1), pos + 1);
// Wert der aktuellen Position ermitteln
result[pos] = result[pos - 1] + result[pos - 2];
// und das Array an die aufrufende Funktion zurückgeben
return result;
}
}
}
Hehe, naja, ich denke, es geht nicht um die Ausgabe, sondern um die Berechnung. Deine Berechnung Methode zur Berechnung hingegen erfolgt ja in jedem Fall rekursiv. Du musst Dir also eine zweite Methode "fibIterativ" einfallen lassen, die Dein Array jetzt eben iterativ füllt und nicht rekursiv, wie die "fib"-Methode.
Naja, zuerst nimmst Du das "Ausgeben" sehr wörtlich.
Du berechnest die Fibonacci Folge nur einmal, undzwar rekursiv.
Lediglich das println wird dann rekursiv, bzw. iterativ ausgegeben.
Davon ab führt Deine fib() Methode zu einem Fehler.
Die erste Eingabe besagt pos ist nicht 1, also führe Else aus.
In dem Else sagst Du
array[1] = fib(pos-1)+fib(pos-2)
fib(pos-1) -> fib(1) gibt array[0]=1 zurück.
fib(pos-2) -> fib(0) führt wieder die Else Anweisung aus, also:
array[0] = fib(0) + fib(-1)
fib(0) führt wieder die Else Anweisung aus, also:
array[-1] = fib(-1) + fib(-2)
Völlig egal wie es ab hier weitergeht, array[-1] gibt es nicht,
heisst hier wirst Du eine ArrayIndexOutOfBoundsException bekommen.
Du hast da anscheinend etwas mit Deiner Variable pos vermurkst.
Da musst Du nochmal drüberschauen.
Eine iterative Lösung könnte sein:
int i=0;
int j=1;
int k=2;
int[]array = {1,1,0,0,0,0,0,0,0,0};
for(int i=0; i<array.length; i++){
array[k]=array[i]+array[j];
k++;
j++;
}
Die Schleife berechnet array[2]=array[1] + array[0] und erhöht die Indexvariablen i, j und k mit jedem Durchlauf um 1.
Dadurch wird danach array[3]=...[2]+...[1] gerechnet.
Danach [4]=[3]+[2],
dann [5]=[4]+[3]
und so weiter. Also genau das, was bei der Fibonacci Folge gemacht wird.
PS. Der Beispielcode ist nicht getestet, der Sinn sollte aber verständlich sein.