For-Schleife in For-Schleife

Bitte aktiviere JavaScript!
Hallo.


Ich möchte gerne eine For-Schleife in einer For-Schleife in einer For-Schleife schreiben. Folgende Situation ist gegeben. Das Programm, soll die Laufzeit bestimmen. Hierzu soll der unten aufgeführte Code 1000 mal durchlaufen werden und anschließend ein Mittelwert berechnet werden (Variable Zeit wird addiert und dann durch 1000 geteilt). Anschließend soll danach dies 30 mal ausgeführt werden und wieder ein Mittelwert gebildet werden um einen verlässlichen Wert zu erhalten.


Java:
    public int suchzeitLinear() {
    
        int suchzahl = liste[zufall.nextInt(liste.length)]; //legt eine zufällige Suchzahl im Array fest
        final long timeStart = System.nanoTime();
        for (int i = 0; i < liste.length; i++){
            if(liste[i] == suchzahl){
                final long timeEnd = System.nanoTime();
                long zeit = timeEnd - timeStart; //Dieser Wert soll für Mittelwert benutzt werden
                System.out.println("Suchzeit: "+zeit+ " "+ suchzahl);
                return i; //wenn gefunden wird beendet
            }
        }
                
        return -1; //wenn nicht gefunden
        
        
    }
Ich habe schon zuvor einige Antworten zwecks Microbenchmarking bekommen, allerdings ist dies etwas zu komplex für mich und ich würde dies erstmal mit den oben genannten For-Schleifen machen.


Vielen Dank schon mal für die Hilfe.
 
A

Anzeige


Vielleicht hilft dir dieser Kurs hier weiter: (hier klicken)
Trenn erst mal die eigentliche Funktion und die Zeitmessung.


Der Rest ist ziemlich einfach:
Code:
zeit_für_dreißig_durchläufe := 0
30 mal:
  zeit_für_tausend_durchläufe := 0
  1_000 mal:
    Zeitmessung starten
    suche ausführen
    zeit_für_tausend_durchläufe += Vergangenen Zeit
  zeit_für_dreißig_durchläufe += zeit_für_tausend_durchläufe / 1_000
zeit := zeit_für_dreißig_durchläufe / 30
das ganze wird aber, wie schon gesagt, ziemlich ungenau werden.
 
Zuletzt bearbeitet:
D
Trenn erst mal die eigentliche Funktion und die Zeitmessung.


Der Rest ist ziemlich einfach:
Code:
zeit_für_dreißig_durchläufe := 0
30 mal:
  zeit_für_tausend_durchläufe := 0
  1_000 mal:
    Zeitmessung starten
    suche ausführen
    zeit_für_tausend_durchläufe += Vergangenen Zeit
  zeit_für_dreißig_durchläufe += zeit_für_tausend_durchläufe / 1_000
zeit := zeit_für_dreißig_durchläufe / 30
[code]

das ganze wird aber, wie schon gesagt, ziemlich ungenau werden.
Danke erst mal.
Ich habe das wie folgt gelöst:


Java:
    public int suchzeitLinear2() {
        
        int zeit1=0; //Zeit für 30
        for (int x=0; x<2;x++) {
        int    zeit2=0; // Zeit für 1000
        for (int j=0; j<2;j++ ) {
            
            int suchzahl = liste[zufall.nextInt(liste.length)]; //legt eine zufällige Suchzahl im Array fest
            final long timeStart = System.nanoTime();
            for (int i = 0; i < liste.length; i++){
                if(liste[i] == suchzahl){
                    final long timeEnd = System.nanoTime();
                    zeit = timeEnd - timeStart; //Dieser Wert soll für Mittelwert benutzt werden
                    System.out.println("Suchzeit: "+zeit+ " "+ suchzahl);
                    return i; //wenn gefunden wird beendet
                }
            }
                    
            zeit2 += zeit;
            return -1; //wenn nicht gefunden
            
        }
        zeit1 += zeit2 /1000;
        }
        
        int zeit3=zeit1/30;
        return zeit3;
    }
Dabei wird die Zeit allerdings nur ein mal gemessen? Kannst du mir da evtl. behilflich sein?

Vielen Dank schon mal.
 
Du willst die Zeit ja auch nur einmal messen: Nämlich dann, wenn du fertig bist.

Weitere Zeitmessungen zwischendurch verzerren dir dein Ergebnis.
 
Du willst die Zeit ja auch nur einmal messen: Nämlich dann, wenn du fertig bist.

Weitere Zeitmessungen zwischendurch verzerren dir dein Ergebnis.
Ich messe die Zeit ja auch nur ab "final long timeStart = System.nanoTime();" bis "final long timeEnd = System.nanoTime();".

Allerdings wird jetzt nur 1 mal nach einer Zahl gesucht und dann abgebrochen. Er sollte doch aber 1000 mal suchen und dann anschließend 30 mal. Kann mir da vielleicht jemand sagen woran das liegt ? Habe ich evtl. etwas falsches in meinem Code ?
 
Eine Methode schreiben, die das Suchen durchführt, völlig ohne Zeitmessung.

Die Zeitmessung passiert dann in einer anderen Methode, in der die Such-Methode aufgerufen wird.
 
Danke. Ich habe das jetzt so gemacht:

Eine Methode schreiben, die das Suchen durchführt, völlig ohne Zeitmessung.

Die Zeitmessung passiert dann in einer anderen Methode, in der die Such-Methode aufgerufen wird.
Java:
    public int suche() {
        
        int suchzahl = liste[zufall.nextInt(liste.length)]; //legt eine zufällige Suchzahl im Array fest
        for (int i = 0; i < liste.length; i++){
            if(liste[i] == suchzahl){
                return i; //wenn gefunden wird beendet
            }
        }
                
        return -1; //wenn nicht gefunden
        
        
    }
    
    
    public int suchzeitLinear2() {
        
        int zeit30=0; //Zeit für 30
        for (int x=0; x<1;x++) {
        int    zeit1000=0; // Zeit für 1000
        for (int j=0; j<5;j++ ) {
            
            final long timeStart = System.nanoTime();
            suche();
            final long timeEnd = System.nanoTime();
            zeit = timeEnd - timeStart; //Dieser Wert soll für Mittelwert benutzt werden
            System.out.println("Zeit: "+zeit);
            zeit1000 += zeit;
    
            
        }
        zeit30 += zeit1000 /1000;
        }
        
        int zeitFinal=zeit30/30;
        return zeitFinal;
    }

Stimmt das so weit?
 
Ich glaube er meint das so:

Java:
public void wasteTime(){
    //waste time with some for-loops
}

public void doBenchmark(){
    startTimemeasure();
    wasteTime();
    stopTimemeasure();
}
 
Stimmt das so weit?
Wie im anderen Thread bereits geschrieben: es ist keine gute Idee long auf int zu addieren, auch wenn es hier keine Rolle spielen dürfte.

Schau Dir einmal unabhängig davon den Code an, was sollen die zwei for-Schleifen bringen und was soll es bringen, die inneren Iterationen einzeln zu messen? Wenn Du in der inneren Schleife 1000-mal die Suche ausführst und in der äußeren 30-mal den Spaß wiederholst, kannst Du genauso gut die Suche 30.000 ausführen. Eine Zeitmessung vorher und danach (s. Kommentar von @White_Fox), Differenz durch 30.000 teilen, fertig.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben