Die vier Sortieralgorithmen die durchschnittliche Laufzeit in Millisekunden

amgadalghabra

Mitglied
Unbenannt.PNG
Hallo zusammen, ich habe diese Aufgabe. Wie kann ich die durschnittliche Laufzeit in Millisekunden ermitteln?

Mein Code, den ich geschrieben habe aber weiß nicht was noch fehlt :

Java:
Mein Code:

import java.util.*;



public class SortierVergleich

{

   public static void randomPermutation(int[] a)

   {

      //einen neuen Zufallszahlengenerator anlegen

      Random gen = new Random();



      for(int i = a.length-1; i > 0; i--)

      {

         //Element fuer Position i zufaellig waehlen

         int p = gen.nextInt(i+1);

        

         //Elemente an Positionen p und i tauschen

         int h = a;

         a  = a[p];

         a[p]  = h;

      }

   }



   public static void fillArray(int[] a)

   {

      for(int i = 0; i < a.length; i++){a = i;}

   }



   public static void main(String[] args)

   {

      int[] folge = new int[Integer.parseInt(args[0])];

      

      fillArray(folge);



      long start = System.currentTimeMillis();

      randomPermutation(folge);

      BubbleSort.performBubbleSortOn(folge);

      long ende = System.currentTimeMillis();



      long dauer = ende - start;



      System.out.println("Das Permutieren hat " + dauer + " Millisekunden gedauert");

   }

}



-----------------------------------------------------------------------------------------------------------------



BubbleSort Code :



class BubbleSort

{

   static void performBubbleSortOn(int[] f)

   {

      boolean getauscht = true;



      while(getauscht)

      {

         getauscht = false;



         //Testen, ob irgendwo noch etwas getauscht

         //werden muss

         for(int i = f.length-1; i > 0; i--)

         {

            if(f < f[i-1])

            {

               int h  = f;

               f   = f[i-1];

               f[i-1] = h;

               getauscht = true;

            }

         }

      }

   }



   static void printArray(int[] a)

   {

      for(int i = 0; i < a.length; i++)

      {

         System.out.print(a + " ");

      }

      System.out.print("\n");

   }



   public static void main(String[] args)

   {

      int[] folge = {13,4,15,3,16,12,2,1,51,26,11};

      

      printArray(folge);



      performBubbleSortOn(folge);



      printArray(folge);

   }

}


Ich wäre seehr dankbar, wenn jemand mir helfen würde....
Vielen Dank im Voraus! :)
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Hier im Editor ist ganz links das Symol </>. Da drückst Du drauf :)

Unabhängig davon:
Wie kann ich die durschnittliche Laufzeit in Millisekunden ermitteln?
System.currentTimeMillis() liefert die aktuelle Zeit in Millisekunden. Du nimmst also Startzeit und Endezeit, die Differenz ist dann die Laufzeit. Wenn Du zwischenzeitlich 100-mal sortiert hast, dann nimmst Du die gemessene Laufzeit, teilst durch 100 und hast das Ergebnis.
 

amgadalghabra

Mitglied
Hier im Editor ist ganz links das Symol </>. Da drückst Du drauf :)

Unabhängig davon:

System.currentTimeMillis() liefert die aktuelle Zeit in Millisekunden. Du nimmst also Startzeit und Endezeit, die Differenz ist dann die Laufzeit. Wenn Du zwischenzeitlich 100-mal sortiert hast, dann nimmst Du die gemessene Laufzeit, teilst durch 100 und hast das Ergebnis.
Danke erstmal für deine Antwort.
Also was soll ich jetzt in meinem Code noch schreiben? was fehlt ihm noch? 🤔
 
Zuletzt bearbeitet:

amgadalghabra

Mitglied
Du musst den Code um das ergänzen, was ich vorhin geschrieben habe.
Ok noch eine Frage , wie kann ich 100 Mal sortieren? 🤔
Wie ich von der Aufgabe verstanden habe, muss ich 100 mal Zahlen von 1 bis n-1 erzeugen und dann die sortieren. Ich habe keine Ahnung wie ich das machen soll. Könntest du mir das noch genauer erklären bitte? und vielen vielen Dank im Voraus für deine Antwort! :)
 

amgadalghabra

Mitglied
Hab gemacht. Könntest du es mir korrigieren bitte wenn es Fehler hätte? :)
Java:
import java.util.*;

public class SortierVergleich
{
   public static void randomPermutation(int[] a)
   {
      //einen neuen Zufallszahlengenerator anlegen
      Random gen = new Random();
      for (int j= 1 ; j<=100; j++){
      for(int i = a.length-1; i > 0; i--)
      {
         //Element fuer Position i zufaellig waehlen
         int p = gen.nextInt(i+1);
        
         //Elemente an Positionen p und i tauschen
         int h = a[i];
         a[i]  = a[p];
         a[p]  = h;
      }
      }
      
   }

   public static void fillArray(int[] a)
   {
      for(int i = 0; i < a.length; i++){a[i] = i;}
   }

   public static void main(String[] args)
   {
      int[] folge = new int[Integer.parseInt(args[0])];
      
      fillArray(folge);

      long start = System.currentTimeMillis();
      randomPermutation(folge);
      BubbleSort.performBubbleSortOn(folge);
      long ende = System.currentTimeMillis();

      long dauer = ende - start;
      dauer = dauer / 100;

      System.out.println("Das Permutieren hat " + dauer + " Millisekunden gedauert");
   }
}
 

mihe7

Top Contributor
Du musst die Schleife, die 100-mal wiederholt, aus randomPermutation entfernen und in die main-Methode reinnehmen (zwischen long start und long ende), denn Du willst ja 100 verschiedene Permutationen sortieren und nicht nur die 100. Permutation einmal sortieren.
 

amgadalghabra

Mitglied
Du musst die Schleife, die 100-mal wiederholt, aus randomPermutation entfernen und in die main-Methode reinnehmen (zwischen long start und long ende), denn Du willst ja 100 verschiedene Permutationen sortieren und nicht nur die 100. Permutation einmal sortieren.
Ach ja stimmt... ich glaube jetzt habe ich das richtig gemacht oder? :D
Java:
 public static void main(String[] args)
   {
      int[] folge = new int[Integer.parseInt(args[0])];
      
      fillArray(folge);

      long start = System.currentTimeMillis();
      for(int i= 1; i<=100; i++)
      {
      randomPermutation(folge);
      BubbleSort.performBubbleSortOn(folge);
      }
      long ende = System.currentTimeMillis();

      long dauer = ende - start;
      dauer = dauer / 100;

      System.out.println("Das Permutieren hat " + dauer + " Millisekunden gedauert");
   }
 

mihe7

Top Contributor
Das ist zumindest der Ansatz. Jetzt müsstest Du halt schauen, ob die Berücksichtigung der Zeit für die Erzeugung der Permutationen der Aufgabenstellung entspricht ;)
 

amgadalghabra

Mitglied
Das ist zumindest der Ansatz. Jetzt müsstest Du halt schauen, ob die Berücksichtigung der Zeit für die Erzeugung der Permutationen der Aufgabenstellung entspricht ;)
Und noch eine Frage. Bei QuickSort und MergeSort funktioniert das irgendwie nicht, weil die Minimalsekunden sind 0 dabei. Z.B bekomme ich das :
Unbenannt.PNG
Wieso denn? Hast du Idee? 🤔
Mein Code in Main:
Java:
long startQ = System.currentTimeMillis();
      for(int i= 1; i<=100; i++)
      {
      randomPermutation(folge); 
      QuickSort.performQuickSort(folge,0,folge.length-1);
      }
      long endeQ = System.currentTimeMillis();

      long dauerQ = endeQ - startQ;
      dauerQ = dauerQ / 100;

      System.out.println("Das Permutieren und die Sortierung durch QuickSort haben " + dauerQ + " Millisekunden gedauert");
 

amgadalghabra

Mitglied
Und noch eine Frage. Bei QuickSort und MergeSort funktioniert das irgendwie nicht, weil die Minimalsekunden sind 0 dabei. Z.B bekomme ich das :
Anhang anzeigen 14465
Wieso denn? Hast du Idee? 🤔
Mein Code in Main:
Java:
long startQ = System.currentTimeMillis();
      for(int i= 1; i<=100; i++)
      {
      randomPermutation(folge);
      QuickSort.performQuickSort(folge,0,folge.length-1);
      }
      long endeQ = System.currentTimeMillis();

      long dauerQ = endeQ - startQ;
      dauerQ = dauerQ / 100;

      System.out.println("Das Permutieren und die Sortierung durch QuickSort haben " + dauerQ + " Millisekunden gedauert");
Class QuickSort:
Java:
class QuickSort
{
   static int partition(int[] f, int a, int b)
   {
      int i = a;
      int j = b-1;

      do
      {
         //naechstes Paar zum Tauschen suchen
         while((f[i] <= f[b]) && (i < b)){i++;}
         while((f[j] >= f[b]) && (j > a)){j--;}
       
         //ggfs. Tauschen
         if(i < j)
         {
            int h = f[i];
            f[i]  = f[j];
            f[j]  = h;
         }
      }while(i < j);

      //ggfs. Pivotelement an die richtige Stelle
      //tauschen
      if(f[i] > f[b])
      {
         int h = f[i];
         f[i]  = f[b];
         f[b]  = h;
      }

      //Position des Pivotelements zurueckgeben
      return i;
   }

   static void performQuickSort(int[] f, int l, int r)
   {
      //Test ob zu sortierender Abschnitt des
      //Arrays mindestens zwei Elemente enthaelt
      if(l < r)
      {
         //bzgl. des Pivotelements aufteilen
         int pivpos = partition(f,l,r);
       
         //rekursiv die Teile sortieren
         performQuickSort(f,l,pivpos-1);
         performQuickSort(f,pivpos+1,r);
      }
   }

   static void printArray(int[] a)
   {
      for(int i = 0; i < a.length; i++)
      {
         System.out.print(a[i] + " ");
      }
      System.out.print("\n");
   }

   public static void main(String[] args)
   {
      int[] folge = {13,4,15,3,16,12,2,1,51,26,11};
     
      printArray(folge);

      performQuickSort(folge,0,folge.length-1);

      printArray(folge);
   }
}

Vielen vielen Dank im Voraus! :)))
 
K

kneitzel

Gast
Du hast ja auch die Aufgabe, es für andere Größen zu machen. Also nicht nur für 5000 Elemente sondern auch für mehr.

Die Ergebnisse, die Du da bekommen hast, sind erst einmal korrekt. Das liegt einfach an Windows, das diese interne Zeit einfach nicht öfter umstellt. Aber wenn das Array größer wird, wird ja auch die benötigte Zeit größer. Wenn Du aber nicht die Zeit selbst sondern nur die vergangene Zeit haben willst, dann könntest Du System.nanoTime() verwenden:
 

amgadalghabra

Mitglied
Du hast ja auch die Aufgabe, es für andere Größen zu machen. Also nicht nur für 5000 Elemente sondern auch für mehr.

Die Ergebnisse, die Du da bekommen hast, sind erst einmal korrekt. Das liegt einfach an Windows, das diese interne Zeit einfach nicht öfter umstellt. Aber wenn das Array größer wird, wird ja auch die benötigte Zeit größer. Wenn Du aber nicht die Zeit selbst sondern nur die vergangene Zeit haben willst, dann könntest Du System.nanoTime() verwenden:
Danke für deine Antwort. Wie kann das aber sein dass das Programm 100 Mal 5000 Elemente in 0 Millisekunden erzeugt und dann sortiert. Das ist irgendwie nicht logisch oder 🤔🤔
 
K

kneitzel

Gast
Also einfach mal erläutert:

Du hast eine Spielzeug Uhr an der Wand in Deinem Zimmer.

Jede Stunde kommt nun Deine Mutter und stellt die Spielzeuguhr um eine Stunde weiter....

Nun nutzt due diese Uhr, um eine Zeit zu messen:

Du schaust auf die Uhr und merkst Dir die Zeit.
Dann machst du etwas ...
Und dann schaust du wieder auf die Uhr und wunderst dich: Es ist keine Zeit vergangen? Wie kann das nur sein?

Und das ist jetzt auch nicht anders, nur eben ist es nicht Dein Zimmer sondern der Computer, es ist keine Spielzeug-Uhr sondern einfach nur ein Speicherbereich, in dem das Betriebssystem (nicht deine Mutter) regelmäßig die korrekte Zeit einstellt.

So wie Deine Mutter hat der Computer auch schlicht etwas besseres zu tun, als ständig deine blöde Uhr umzusetzen. Daher scheint es so, als ob keine Zeit vergeht.
 

amgadalghabra

Mitglied
Also einfach mal erläutert:

Du hast eine Spielzeug Uhr an der Wand in Deinem Zimmer.

Jede Stunde kommt nun Deine Mutter und stellt die Spielzeuguhr um eine Stunde weiter....

Nun nutzt due diese Uhr, um eine Zeit zu messen:

Du schaust auf die Uhr und merkst Dir die Zeit.
Dann machst du etwas ...
Und dann schaust du wieder auf die Uhr und wunderst dich: Es ist keine Zeit vergangen? Wie kann das nur sein?

Und das ist jetzt auch nicht anders, nur eben ist es nicht Dein Zimmer sondern der Computer, es ist keine Spielzeug-Uhr sondern einfach nur ein Speicherbereich, in dem das Betriebssystem (nicht deine Mutter) regelmäßig die korrekte Zeit einstellt.

So wie Deine Mutter hat der Computer auch schlicht etwas besseres zu tun, als ständig deine blöde Uhr umzusetzen. Daher scheint es so, als ob keine Zeit vergeht.
Danke für die tolle Erklärung! :)
Ich bekomme immer verschiedene Werte. Was soll ich dann in der Tabelle schreiben?.. 🤔
Unbenannt.PNG
 
K

kneitzel

Gast
Das ist auch normal, denn
a) Dein Rechner macht ja mehrere Dinge gleichzeitig und die Leistung kann schwanken.
b) Je nachdem, wie das Array aussieht kann die Sortierung unterschiedlich schnell gehen.

Daher sind nie immer die genau gleichen Werte zu erwarten. Aber grob stimmen diese ja überein.
 

amgadalghabra

Mitglied
Das ist auch normal, denn
a) Dein Rechner macht ja mehrere Dinge gleichzeitig und die Leistung kann schwanken.
b) Je nachdem, wie das Array aussieht kann die Sortierung unterschiedlich schnell gehen.

Daher sind nie immer die genau gleichen Werte zu erwarten. Aber grob stimmen diese ja überein.
Such Dir einfach einen Lauf aus. Es geht hier nur um Größenordnungen.
Alles klar. :) noch eine Frage (Sorry wenn ich viele Fragen stelle aber nur um alles komplett zu verstehen) im Skript steht das

Unbenannt.PNG


Heißt das dass wir der Durschnitt der Laufzeit falsch gemacht, dass wir Startzeit und Endezeit, nehmen und dann die Differenz die Laufzeit ist? 🤔 oder was bedeutet das im Bild?
 
K

kneitzel

Gast
Nein, das ist alles ok soweit.

Was Du gemacht hast, ist einfach nur die konkrete Laufzeit zu ermitteln. Das hat erst einmal mit der Angabe die Du jetzt gepostet hast, noch nicht viel zu tun.

Was Du im Bild angibst, ist das Verhalten der Laufzeit, wenn man die Anzahl der Elemente (als n angeben) verändert.

Dabei sind Konstanten egal. O(n) würde bedeuten, dass sich die Laufzeit verdoppelt, wenn sich die Anzahl der Elemente verdoppelt.
Also wenn Du für 100 Elemente die Zeit x gemessen hast, dann sollte es für 200 Element auf 2*x hinaus laufen.

Bei O(n²) bedeutet das: Wenn sich n verdoppelt, dann wird sich die Zeit vervierfachen! Also 100 Elemente in Zeit x -> 200 Elemente 2*x an Zeit.

Dabei ist egal, was x ist. Die 100 Elemente kann er in 1ns, 1s, 1h, 1 Tag oder in 1 Jahr hin bekommen haben. Das ist ein konstanter Faktor, den man bei eine O-Angabe ignoriert. Denn es geht um das Laufzeitverhalten des Algorithmus. Das ist ein Faktor, der aber massiv vom System beeinflusst ist: eine 1MHz 8Bit CPU braucht halt einen riesigen Faktor mehr als eine 4GHz High End CPU....

Und es wird auch grob vereinfacht. Also O(n²) oder O(n²+n) - das +n spielt bei großem n keine Rolle:
Das sieht man schnell: n² + n = n*(n+1) und bei großem n kann man das +1 ignorieren....

Was Ihr oder Du da jetzt gemacht habt:
Auf einer Hardware (Das ist jetzt Dein Rechner) wurde der Algorithmus für diverse n ausgeführt.
Und da sollte ein Verhalten wie da angegeben wurde, erkennbar sein. Also bei O(n²) sollte bei einer Verdoppelung von n die vierfache Zeit benötigt werden. Und Du hast ja diverse n (5.000, 10.000, 20.000 und 40.000 - also immer eine Verdoppelung...)
 

amgadalghabra

Mitglied
Nein, das ist alles ok soweit.

Was Du gemacht hast, ist einfach nur die konkrete Laufzeit zu ermitteln. Das hat erst einmal mit der Angabe die Du jetzt gepostet hast, noch nicht viel zu tun.

Was Du im Bild angibst, ist das Verhalten der Laufzeit, wenn man die Anzahl der Elemente (als n angeben) verändert.

Dabei sind Konstanten egal. O(n) würde bedeuten, dass sich die Laufzeit verdoppelt, wenn sich die Anzahl der Elemente verdoppelt.
Also wenn Du für 100 Elemente die Zeit x gemessen hast, dann sollte es für 200 Element auf 2*x hinaus laufen.

Bei O(n²) bedeutet das: Wenn sich n verdoppelt, dann wird sich die Zeit vervierfachen! Also 100 Elemente in Zeit x -> 200 Elemente 2*x an Zeit.

Dabei ist egal, was x ist. Die 100 Elemente kann er in 1ns, 1s, 1h, 1 Tag oder in 1 Jahr hin bekommen haben. Das ist ein konstanter Faktor, den man bei eine O-Angabe ignoriert. Denn es geht um das Laufzeitverhalten des Algorithmus. Das ist ein Faktor, der aber massiv vom System beeinflusst ist: eine 1MHz 8Bit CPU braucht halt einen riesigen Faktor mehr als eine 4GHz High End CPU....

Und es wird auch grob vereinfacht. Also O(n²) oder O(n²+n) - das +n spielt bei großem n keine Rolle:
Das sieht man schnell: n² + n = n*(n+1) und bei großem n kann man das +1 ignorieren....

Was Ihr oder Du da jetzt gemacht habt:
Auf einer Hardware (Das ist jetzt Dein Rechner) wurde der Algorithmus für diverse n ausgeführt.
Und da sollte ein Verhalten wie da angegeben wurde, erkennbar sein. Also bei O(n²) sollte bei einer Verdoppelung von n die vierfache Zeit benötigt werden. Und Du hast ja diverse n (5.000, 10.000, 20.000 und 40.000 - also immer eine Verdoppelung...)
Ich glaube dass das Bild was mit der Frage in der Aufgabe zu tun hat ( Decken sich Ihre gemessenen Laufzeiten mit den
Ergebnissen der Laufzeitanalyse aus der Vorlesung?). Und wie ich von deiner Erklärung verstanden habe decken sich dann die gemessenen Laufzeit damit oder? 😁
 
K

kneitzel

Gast
Ich habe jetzt keine Tabelle von dir gesehen mit den jeweiligen Zahlen, aber so Du die Algorithmen richtig implementiert hast, wird es stimmen ....
 

White_Fox

Top Contributor
@amgadalghabra
Studieren heißt ja vor allem auch, mal herumzuprobieren und zu experimentieren. Gerade wenn es "nur" Software ist, sollte man etwas auch mal kaputtspielen. Genau dafür sind Laborversuche oder Praxisübungen da: Um der Welt beim Funktionieren zuzusehen und daraus zu lernen. Einfach nur auf die richtige Lösung zu kommen ist was für Durchschnittsschüler, aber wer nicht nur Wissen sondern auch Erkenntnis erlangen will sollte mit den Lösungen danach noch etwas machen.

Also mach doch mal Folgends: Erweitere dein Programm dahingehend, daß du es in mehreren Durchgängen durchführst. Im ersten Durchgang wirfst du deinen Algorithmen ein zufälliges Array zum Fraße vor. Im zweiten ein fast fertig sortiertes Array, z.B. immer nur Nachbarn vertauschen, und im dritten Durchgang ein maximal unsortiertes Array. Im vierten Durchgang überlegst du dir selber was, du könntest z.B. mal jeden Algorithmus durchgehen und ein Array erzeugen, daß speziell für diesen Algorithmus der schlechteste Fall ist. Und dann nicht nur mit einer Anzahl von Elementen, sondern steigere die Anzahl. Faktor 10, 15, 20, ...
Einer guten Vergleichbarkeit zuliebe wäre es nützlich, für jeden Durchgang das gleiche Array zu verwenden (also vorm sortieren kopieren).

Und dann schreib dir mal die Zahlen auf und denk über die Ergebnisse nach. Hilfreich ist es auch sich das mal graphisch darzustellen, aus Kurven kann man mehr lesen als aus reinen Zahlenkolonnen.

Edit: Es ist zwar viel Fleißarbeit, aber ich fand das eigentlich immer am interessantesten: Nachdem das Mindesmaß erfüllt (also die Aufgabe wie gefordert gelöst) ist, mich mal ranzusetzen und selber herumzuprobieren. Ich bin auch kein Informatiker, sondern E-Techniker, da braucht man meistens noch irgendwelche Meßgeräte und eine unkaputtbare Laborumgebung, aber der Unterschied zwischen Wissen und Erkenntnis dürfte in der Informatik auf dem gleichen Weg zustandekommen.
Und eigentlich ist das auch am lehrreichsten: Manchmal kommen dabei sehr überraschende Ergebnisse heraus, funktioniert anders als erwartet...und selbst wenn es gar nicht mehr funktioniert oder kaputtgeht bleibt immer noch die Frage, warum es so kam wie es gekommen ist.
 
Zuletzt bearbeitet:

amgadalghabra

Mitglied
@amgadalghabra
Studieren heißt ja vor allem auch, mal herumzuprobieren und zu experimentieren. Gerade wenn es "nur" Software ist, sollte man etwas auch mal kaputtspielen. Genau dafür sind Laborversuche oder Praxisübungen da: Um der Welt beim Funktionieren zuzusehen und daraus zu lernen. Einfach nur auf die richtige Lösung zu kommen ist was für Durchschnittsschüler, aber wer nicht nur Wissen sondern auch Erkenntnis erlangen will sollte mit den Lösungen danach noch etwas machen.

Also mach doch mal Folgends: Erweitere dein Programm dahingehend, daß du es in mehreren Durchgängen durchführst. Im ersten Durchgang wirfst du deinen Algorithmen ein zufälliges Array zum Fraße vor. Im zweiten ein fast fertig sortiertes Array, z.B. immer nur Nachbarn vertauschen, und im dritten Durchgang ein maximal unsortiertes Array. Im vierten Durchgang überlegst du dir selber was, du könntest z.B. mal jeden Algorithmus durchgehen und ein Array erzeugen, daß speziell für diesen Algorithmus der schlechteste Fall ist. Und dann nicht nur mit einer Anzahl von Elementen, sondern steigere die Anzahl. Faktor 10, 15, 20, ...
Einer guten Vergleichbarkeit zuliebe wäre es nützlich, für jeden Durchgang das gleiche Array zu verwenden (also vorm sortieren kopieren).

Und dann schreib dir mal die Zahlen auf und denk über die Ergebnisse nach. Hilfreich ist es auch sich das mal graphisch darzustellen, aus Kurven kann man mehr lesen als aus reinen Zahlenkolonnen.

Edit: Es ist zwar viel Fleißarbeit, aber ich fand das eigentlich immer am interessantesten: Nachdem das Mindesmaß erfüllt (also die Aufgabe wie gefordert gelöst) ist, mich mal ranzusetzen und selber herumzuprobieren. Ich bin auch kein Informatiker, sondern E-Techniker, da braucht man meistens noch irgendwelche Meßgeräte und eine unkaputtbare Laborumgebung, aber der Unterschied zwischen Wissen und Erkenntnis dürfte in der Informatik auf dem gleichen Weg zustandekommen.
Und eigentlich ist das auch am lehrreichsten: Manchmal kommen dabei sehr überraschende Ergebnisse heraus, funktioniert anders als erwartet...und selbst wenn es gar nicht mehr funktioniert oder kaputtgeht bleibt immer noch die Frage, warum es so kam wie es gekommen ist.
Ja mache ich vielen Dank für den Tipp :))
 

mrBrown

Super-Moderator
Mitarbeiter
Im ersten Durchgang wirfst du deinen Algorithmen ein zufälliges Array zum Fraße vor. Im zweiten ein fast fertig sortiertes Array, z.B. immer nur Nachbarn vertauschen, und im dritten Durchgang ein maximal unsortiertes Array.
mit "zufällig" und "maximal unsortiert" meinst du sicherlich unterschiedliches? Wenn ich raten müsste mein letzteres "falschrum sortiert"?
 

amgadalghabra

Mitglied
Kannst ja mal ausrechnen.

Bubblesort hat O(n²). Wenn du also n verdoppelst, was erwartest du ungefähr an Vergrößerung der Laufzeit? Da quadratisch ca. 4 fache Laufzeit. Wenn mal das Beispiel mit den 5000 => 1000 nimmt von 22 Millisekunden auf 114. 22*4 ist 88, also kommt ungefähr hin,.
mit den 10000 => 20000 nimmt von 114 Millisekunden auf 690. 114*4 ist 456 und 20000 => 40000 nimmt von 690 Millisekunden auf 3224. 690*4 ist 2760

InsertionSort hat auch O(n²) 5000=> 10000 nimmt von 3 auf 13 Millisekunden also 3 * 4 ist 12
10000 => 20000 : 13 =>73 also 13*4 ist 52
20000 => 40000 : 73 => 292 also 73* 4 ist 292


QuickSort hat auch O(n²) 5000=> 10000 nimmt von 0 auf 0 Millisekunden also 0
10000 => 20000 : 0 =>2 ist 0 aber gleich wie 2
20000 => 40000 : 2 => 5 also 2* 4 ist 8


MergeSort hat auch O(n log n) 5000=> 10000 nimmt von 1 auf 1 Millisekunden also 1 log 1 ist 0
10000 => 20000 : 1 =>5 ist 0
20000 => 40000 : 5 => 10 also 5 log 5 ist 3.5

Die Werte kommen ungefähr hin also decken sich mit den
Ergebnissen 🤷‍♂️



 

White_Fox

Top Contributor
mit "zufällig" und "maximal unsortiert" meinst du sicherlich unterschiedliches? Wenn ich raten müsste mein letzteres "falschrum sortiert"?
Nun - ich bin kein Informatiker, und von Programmierung habe ich auch keine Ahnung. ;)
Mit "maximal unsortiert" meine ich in der Tat die Sortierung, für die ein Algorithmus am längsten braucht. Bei Bubblesort dürfte das in der Tat die "invertierte Sortierung" sein, ich weiß aber nicht ob das für alle Sortieralgorithmen der ungünstigste Fall ist. Das ist zwar unsortiert, aber eben nicht zufällig.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
M Minimax-Algorithmus für Vier gewinnt Java Basics - Anfänger-Themen 11
M GUI für Vier-Gewinnt. Java Basics - Anfänger-Themen 4
J Vier gewinnt in Java,Spieler Konstruktor Java Basics - Anfänger-Themen 8
C alle möglichen Kombinationen zweier Ziffern auf drei / vier / und 'n" Stellen Java Basics - Anfänger-Themen 11
Kamy Ein einfaches "Vier Gewinnt" Spiel für Anfängerin Java Basics - Anfänger-Themen 51
H Vier Augen sehen mehr... Java Basics - Anfänger-Themen 6
S Die ersten vier perfekte Zahlen. Java Basics - Anfänger-Themen 30
A Klassen Klasse um einen Wert zu vier Zahlen zu speichern Java Basics - Anfänger-Themen 7
A Tic Tac Toe - Vier Gewinnt Java Basics - Anfänger-Themen 5
E Weiteres Vier Gewinnt-Spiel Java Basics - Anfänger-Themen 2
J Reset Button im Spiel Vier gewinnt einrichten Java Basics - Anfänger-Themen 8
G boolean Methode Vier gewinnt Java Basics - Anfänger-Themen 6
G Algorithmus im Spiel "vier gewinnt" Java Basics - Anfänger-Themen 3
T Sortieralgorithmen richtig? Java Basics - Anfänger-Themen 1
S SortierAlgorithmen Java Basics - Anfänger-Themen 5
M Laufzeitverhalten von Sortieralgorithmen darstellen Java Basics - Anfänger-Themen 3
V Durchschnittliche Volatility in Prozent für 4 Stunden berechnen Java Basics - Anfänger-Themen 14
S Die durchschnittliche Länge der Strings Java Basics - Anfänger-Themen 11
R Durchschnittliche Pfadlänge eines binärem Baumes Java Basics - Anfänger-Themen 22

Ähnliche Java Themen

Neue Themen


Oben