Quicksort

Quicksort für das Wort "informatik"

im Zentralabitur nur relevant für den LK!

Diese Seite entspricht dem Abi 17 (und folgenden)

Prinzip

Quicksort arbeitet nach dem Divide-and-Conquer-Prinzip:

Zunächst wird die zu sortierende Liste in zwei Teillisten („linke“ und „rechte“ Teilliste) getrennt (=Divide). Dazu wählt Quicksort ein sogenanntes Pivotelement aus der Liste aus. Alle Elemente, die kleiner als das Pivotelement sind, kommen in die linke Teilliste, und alle, die größer sind, in die rechte Teilliste. Die Elemente, die gleich dem Pivotelement sind, können sich beliebig auf die Teillisten verteilen. Nach der Aufteilung sind die Elemente der linken Liste kleiner oder gleich den Elementen der rechten Liste.

Anschließend wird jede Teilliste in sich sortiert. Dazu wird der Quicksort-Algorithmus rekursiv auf der linken und auf der rechten Teilliste ausgeführt. Wenn eine Teilliste leer ist, erfolgt der Abbruch der Rekursion, d. h. für diese Teilliste wird Quicksort nicht mehr aufgerufen.

Am Ende werden die beiden Teillisten und das Pivot-Element zusammengeführt (=Conquer).

Laufzeit

Quicksort hat im Average Case die Laufzeit O(n*log(n)). Im Worst Case steigt die Laufzeit auf O(n²).
Da der Worst Case nur für Listen (bzw. Arrays) eintritt, die schon sortiert sind, kann man den Worst Case ganz einfach vermeiden: Man muss vor dem Aufruf von Quicksort die Elemente mischen!

Quicksort ist das schnellste vergleichsbasierte Sortierverfahren. Das liegt daran, dass es für Arrays in situ sortiert, d.h. es müssen keine neuen Datenstrukturen erzeugt werden. Das ist der entscheidende Vorteil von Quicksort gegenüber Mergesort.

Implementierung

für Listen

Quicksort-Implementierung für eine Liste (vgl. Schnittstellenbeschreibung Zentralabitur), die mit Objekten vom Typ Person gefüllt ist.

Diese Implementierung ist einfacher als die Array-Implementierung, dafür aber nicht so schnell, denn man muss ständig neue Listen erzeugen.

 public List<Person> quicksort(List<Person> pList){
   if(pList.isEmpty()){
     return pList;
   }
   pList.toFirst();
   Person pivot = pList.getContent();
   pList.next();
   if(!pList.hasAccess()){
     return pList;
   }
   List<Person> kleiner = new List<>();
   List<Person> groesser = new List<>();
   while(pList.hasAccess()){
     Person aktuell = pList.getContent();
     if(aktuell.getEinkommen() < pivot.getEinkommen()){
       kleiner.append(aktuell);
     }
     else{
       groesser.append(aktuell);
     }
     pList.next();
   }
   List<Person> kleinerSortiert = quicksort(kleiner);
   List<Person> groesserSortiert = quicksort(groesser);

   List<Person> ergebnis = new ListWithViewer<>();
   ergebnis.concat(kleinerSortiert);
   ergebnis.append(pivot);
   ergebnis.concat(groesserSortiert);
   return ergebnis;
 }

für Arrays

Auf Arrays ist Quicksort schneller, weil man "in situ" sortiert, d.h. es werden keine Teilarrays o.ä. erzeugt.

Dafür ist diese Implementierung komplizierter.

  //Rahmenmethode
  public void quicksort(Person[] personen){
     quicksort(personen, 0, personen.length-1);
  }

  // rekursive Methode
  private void quicksort(Person[] personen, int start, int ende){
     if(start == ende){
        return;
     }
     if(start + 1 == ende){
        if(personen[start].istAlphabetischNach(personen[ende])){
           tausche(personen, start, ende);
           return;
        }
     }
     Person pivot = personen[start];
     int vomStart = start+1;
     int vomEnde = ende;
     while(vomStart < vomEnde){
        while(vomStart < vomEnde && personen[vomStart].istAlphabetischNach(pivot) == false){
           vomStart++;
        }
        while(vomStart < vomEnde && personen[vomEnde].istAlphabetischNach(pivot)){
           vomEnde--;
        }
        tausche(personen, vomStart, vomEnde);
     }
     // pivot-Element in die Mitte bringen
     tausche(personen, start, vomStart-1);
     if(start < vomStart-1){
        quicksort(personen, start, vomStart-1);
     }
     if(vomStart < ende){
        quicksort(personen, vomStart, ende);
     }
     return;
  }