ich hab ein problem ich muss jeweils (getrennt für die Methoden fibIterative und
fibRecursive) über 10 Iterationen hinweg die durchschnittliche Zeit, die für das
Ermitteln der Fibonacci-Zahl für Werte von 0 <= n <= 30 benötigt wird ermitteln und das soll ich dann in der Main-Methode ausgeben.
Und das ist mein Kunstwerk was ich so gemacht habe. Ich hoffe es kann mir jemand
weiter helfen
Code:
public class Fibo {
// Main-Methode zum Testen
public static void main(String[] args) {
//Instanz
Fibo fibo = new Fibo();
System.out.println("Hier"+fibo.fibIterative(30));
// Array
long[] zeitspeicher = new long[10];
//Zuweisung über eine Schleife
for (int a = 0; a < zeitspeicher.length; a++) {
long startzeit=System.currentTimeMillis();
int result=fibo.fibIterative(30);
long endzeit=System.currentTimeMillis();
long duration=endzeit-startzeit;
zeitspeicher[a]=duration+a;
System.out.println(duration);
}
//Ausgabe über Schleife
/*for (long a : zeitspeicher) {
System.out.println("da"+a/10);
}*/
}
/**
* Berechnet die n-te Fibonacci-Zahl rekursiv.
*
* @param n
* Die zu berechnende Fibonacci-Zahl.
* @return Wert der zu berechnenden Fibonacci-Zahl.
*/
public int fibRecursive(final int n) {
if (n == 0) {
return n;
}
if (n == 1) {
return n;
}
return fibRecursive(n - 1) + fibRecursive(n - 2);
}
/**
* Berechnet die n-te Fibonacci-Zahl iterativ.
*
* @param n
* Die zu berechnende Fibonacci-Zahl.
* @return Wert der zu berechnenden Fibonacci-Zahl.
*/
public int fibIterative(final int n) {
int ergebnissFibo=0;
for (int k=0; k<10; k++) {
int currentFib = 0;
int nextFib = 1;
for (int i = 0; i < n; i++) {
int tmp = nextFib;
nextFib = currentFib + nextFib;
currentFib = tmp;
}
ergebnissFibo=currentFib; //return currentFib;
}
return ergebnissFibo;
}
}
Der Fehler liegt darin, dass du versuchst in Millisekunden zu rechnen. Java erledigt die Aufgabe zu schnell, daher kommt da immer 0 ms raus. Nimm Nanosekunden.
Code:
public class Fibo {
// Main-Methode zum Testen
public static void main(String[] args) {
//Instanz
Fibo fibo = new Fibo();
long summe = 0;
int durchlaeufe = 10;
//Zuweisung über eine Schleife
for (int a = 0; a < durchlaeufe; a++) {
long startzeit=System.nanoTime();
fibo.fibIterative(30);
long endzeit=System.nanoTime();
long duration=endzeit-startzeit;
summe = summe + (int)duration;
}
System.out.println("Durchschnitt: "+(double)summe/(double)durchlaeufe+" ns");
}
/**
* Berechnet die n-te Fibonacci-Zahl rekursiv.
*
* @param n
* Die zu berechnende Fibonacci-Zahl.
* @return Wert der zu berechnenden Fibonacci-Zahl.
*/
public int fibRecursive(final int n) {
if (n == 0) {
return n;
}
if (n == 1) {
return n;
}
return fibRecursive(n - 1) + fibRecursive(n - 2);
}
/**
* Berechnet die n-te Fibonacci-Zahl iterativ.
*
* @param n
* Die zu berechnende Fibonacci-Zahl.
* @return Wert der zu berechnenden Fibonacci-Zahl.
*/
public int fibIterative(final int n) {
int ergebnissFibo=0;
for (int k=0; k<10; k++) {
int currentFib = 0;
int nextFib = 1;
for (int i = 0; i < n; i++) {
int tmp = nextFib;
nextFib = currentFib + nextFib;
currentFib = tmp;
}
ergebnissFibo=currentFib; //return currentFib;
}
return ergebnissFibo;
}
}
Danke für deine Hilfe :toll:
Ich hatte ja gar nicht so große Fehler oder ???:L
Aber wie kann ich denn jetzt die Zeit für der rekursiven Prozess ausgeben, ich
kann mit der Rekursion nicht viel anfangen. Deshalb bräuchte ich da mal
ne Starthilfe
Danke für deine Hilfe :toll:
Ich hatte ja gar nicht so große Fehler oder ???:L
Aber wie kann ich denn jetzt die Zeit für der rekursiven Prozess ausgeben, ich
kann mit der Rekursion nicht viel anfangen. Deshalb bräuchte ich da mal
ne Starthilfe
LOL!
Indem du einfach die Zeile
fibo.fibIterative(30);
ersetzt durch
fibo.fibRecursive(30);
Was das ganze wahrscheinlich zeigen soll: Für kleine Werte bspw. 30 ist die Rekursion wesentlich schneller als die iterative Variante aber tausch doch mal das 30 durch 3000 aus, dann siehts gleich anders aus.
Also hier hab ich meine Rekursivevariante, einfach nur die Zeile ersetzen geht ja nicht,
also geht schon aber ich bekomme ja immer nur dann entweder Iteration oder die
Rekursion auf die Console geliefert. Aber meine Rekursion dauert länger als meine Iteration. Stimmt das? ???:L
Code:
public class Fibo {
// Main-Methode zum Testen
public static void main(String[] args) {
//ITERATIV
//Instanz
Fibo fiboIter = new Fibo();
long summe = 0;
int durchlaeufe = 10;
//Zuweisung über eine Schleife
for (int a = 0; a < durchlaeufe; a++) {
long startzeit=System.nanoTime();
fiboIter.fibRecursive(30);
long endzeit=System.nanoTime();
long duration=endzeit-startzeit;
summe = summe + (int)duration;
}
System.out.println("Durchschnitt Iterativ: "+(double)summe/(double)durchlaeufe+" ns");
//REKURSIV
Fibo fiboRek = new Fibo();
long summe1=0;
for (int a = 0; a < durchlaeufe; a++) {
long startzeit=System.nanoTime();
fiboRek.fibRecursive(30);
long endzeit=System.nanoTime();
long duration=endzeit-startzeit;
summe1 = summe1 + (int)duration;
}
System.out.println("Durchschnitt Rekursiv: "+(double)summe1/(double)durchlaeufe+" ns");
}
/**
* Berechnet die n-te Fibonacci-Zahl rekursiv.
*
* @param n
* Die zu berechnende Fibonacci-Zahl.
* @return Wert der zu berechnenden Fibonacci-Zahl.
*/
public int fibRecursive(final int n) {
if (n == 0) {
return n;
}
if (n == 1) {
return n;
}
return fibRecursive(n - 1) + fibRecursive(n - 2);
}
/**
* Berechnet die n-te Fibonacci-Zahl iterativ.
*
* @param n
* Die zu berechnende Fibonacci-Zahl.
* @return Wert der zu berechnenden Fibonacci-Zahl.
*/
public int fibIterative(final int n) {
int ergebnissFibo=0;
for (int k=0; k<10; k++) {
int currentFib = 0;
int nextFib = 1;
for (int i = 0; i < n; i++) {
int tmp = nextFib;
nextFib = currentFib + nextFib;
currentFib = tmp;
}
ergebnissFibo=currentFib; //return currentFib;
}
return ergebnissFibo;
}
}
