Der Algorithmus
Der Counting Sort ist ein Out-of-place-Sortieralgorithmus, da er das zu sortierende Array im Gegensatz zu Quick Sort oder Bubble Sort nicht direkt sortiert, sondern vorher eine Speicherkopie anlegt, die im Abschluss auf das zu sortierende Array kopiert wird.
Der Algorithmus ist genau dann effizient, wenn man viele (doppelte) Zahlen in einem kleinem Wertebereich / einer engen Min-/Max-Range sortieren möchte.
Wenn man z.B. ein Array mit dem Aufkommen von Menschen nach Alter in der deutschen Bevölkerung sortieren möchte, so hätte man eine Array-Größe von ca. 80 Millionen Einträgen. Da es aber keine Menschen über 120 Jahren in Deutschland gibt, oder der älteste noch lebende Mensch in Deutschland aktuell jünger als 120 Jahre ist, kann man den Wertebereich zwischen 0 und 120 Jahren einschränken.
- Kleiner Wertebereich: Alter zwischen 0 und 120 Jahren.
- Großes Array: 80 Millionen Einträge für jeden Menschen
Für diese Fälle eignet sich der Counting Sort Algorithmus ausgezeichnet, da er nach der folgenden Vorgehensweise vor geht:
- Ermittle den maximalen Wert des Wertebereichs für das Histogramm (z.B. höchstes Alter 120 Jahre)
- Initialisiere ein sortiertes Histogramm als Array mit 0-Werten.
- Laufe das große Array in einer O(n)-Schleife durch (z.B. das Array mit den 80 Mio. Menschen)
- Zähle die Histogramm-Array-Werte über die Vorkommnisse/Häufigkeiten beim Durchlaufen um 1 nach oben, je nachdem welche Zahl bei dem Durchlauf gefunden wird
- Laufe das erstellte Histogramm-Array von links nach rechts durch und füge die Vorkommnisse der Zahlen in das Ziel-Array ein, so dass bei 2x der Zahl 1 und 4x der Zahl 2 so etwas rauskommt: 1;1;2;2;2;2
- Auf diese Weise wurde anhand des sortierten Histogramm-Arrays die Zahlenmenge sortiert
package AlgoDat;
import java.util.Arrays;
public class CountingSort {
// Zu sortierendes Array
private int myArray[] = {22, 6, 2, 4, 10, 3, 9, 7, 5, 8, 1};
// Hält die Klasse als instanziertes Objekt
@SuppressWarnings("unused")
private static CountingSort program;
private java.util.Random rnd = new java.util.Random();
// Hilfsfunktion für das Ausgeben des Arrays
public void OutputOfIntArray(int myArray[])
{
if (myArray != null)
{
for (int i = 0; i < myArray.length; i++) {
if (i > 0) System.out.print(";");
System.out.print(myArray[i]);
}
System.out.println();
}
}
// Generiert ein zufälliges Integer-Array der Größe size mit Werten zwischen 0 und upperLimit
public int[] generateIntegerArrayOfSize(int size, int upperLimit)
{
int[] generatedArray = new int[size];
for (int i = 0; i < generatedArray.length; i++)
{
generatedArray[i] = rnd.nextInt(upperLimit);
}
return generatedArray;
}
// Konstruktor
public CountingSort()
{
System.out.println("Kleines Array");
System.out.println("=============");
System.out.print("Vorher: ");
this.OutputOfIntArray(myArray);
long startTime = System.nanoTime();
this.sort(myArray, false);
long endTime = System.nanoTime();
System.out.print("Nachher: ");
this.OutputOfIntArray(myArray);
System.out.println("Ich habe " + (endTime-startTime) + " ns mit einem Array von " + myArray.length + " und einem Wertebereich/Histogramm von " + Arrays.stream(myArray).max().getAsInt() + " Zahlen gebraucht! \n\n");
System.out.println("Großes Array, kleiner Wertebereich");
System.out.println("==================================");
System.out.print("Vorher: ");
int[] grossesArray = this.generateIntegerArrayOfSize(10000000, 100000);
startTime = System.nanoTime();
this.sort(grossesArray, false);
endTime = System.nanoTime();
System.out.println("Ich habe " + (endTime-startTime) + " ns mit einem Array von " + grossesArray.length + " und einem Wertebereich/Histogramm von " + Arrays.stream(grossesArray).max().getAsInt() + " Zahlen gebraucht! \n\n");
System.out.println("Kleines Array, großer Wertebereich");
System.out.println("==================================");
System.out.print("Vorher: ");
int[] kleinesArray = this.generateIntegerArrayOfSize(100000, 10000000);
startTime = System.nanoTime();
this.sort(kleinesArray, false);
endTime = System.nanoTime();
System.out.println("Ich habe " + (endTime-startTime) + " ns mit einem Array von " + kleinesArray.length + " und einem Wertebereich/Histogramm von " + Arrays.stream(kleinesArray).max().getAsInt() + " Zahlen gebraucht! \n\n");
}
public void sort(int[] myArray)
{
this.sort(myArray, true);
}
public void sort(int[] myArray, boolean verbose)
{
//int maxValue = findMax(elements);
int maxValue = Arrays.stream(myArray).max().getAsInt();
int[] counts = new int[maxValue + 1];
// Phase 1: Erstelle das Histogramm
for (int element : myArray)
{
counts[element]++;
}
if (verbose)
{
System.out.println("Erstelle Histogramm als Array mit den Häufigkeiten der Zahlen im Array");
// Optional - kann auskommentiert werden: Headline von Histogramm und Ausgabe Histogramm
for (int i = 0; i < maxValue; i++)
{
System.out.print(i);
if (i + 1 != maxValue)
{
System.out.print(";");
}
}
System.out.println("");
this.OutputOfIntArray(counts);
}
// Phase 2: Aggregiere die Zahlen, um die Startadressen in Zielarray zu ermitteln
for (int i = 1; i <= maxValue; i++)
{
// Die Daten im Array werden von links nach rechts kummuliert
// um die Startadresse für jede Zahl zu bekommen.
counts[i] += counts[i - 1];
}
if (verbose)
{
System.out.println("Array mit den aggregierten Zahlen (Histogramm) für die Startadresse im Zielarray:");
this.OutputOfIntArray(counts);
}
// Phase 3: Schreibe die Zahlen ins Zielarray
int[] target = new int[myArray.length];
for (int i = myArray.length - 1; i >= 0; i--)
{
int element = myArray[i];
counts[element] = counts[element] - 1;
if (verbose)
{
System.out.println("Schreibe " + element +" an Index " + counts[element] + " des zu sortierten Arrays!");
}
target[counts[element]] = element;
}
// Copy target back to input array
System.arraycopy(target, 0, myArray, 0, myArray.length);
}
public static void main(String[] args)
{
// Instanziere aus den statischem Programm ein echtes Objekt
// damit nicht alle Methoden und Variablen static sein müssen.
program = new CountingSort();
}
}
Ausgabe
Kleines Array
=============
Vorher: 22;6;2;4;10;3;9;7;5;8;1
Nachher: 1;2;3;4;5;6;7;8;9;10;22
Ich habe 12449300 ns mit einem Array von 11 und einem Wertebereich/Histogramm von 22 Zahlen gebraucht!
Großes Array, kleiner Wertebereich (Ausgabe aus)
================================================
Ich habe 75933500 ns mit einem Array von 10000000 und einem Wertebereich/Histogramm von 99999 Zahlen gebraucht!
Kleines Array, großer Wertebereich (Ausgabe aus)
================================================
Ich habe 25634500 ns mit einem Array von 100000 und einem Wertebereich/Histogramm von 9999905 Zahlen gebraucht!
Komplexität: O-Notation (Ordnung)
Die Laufzeit der Funktion hängt von (Anzahl der Elemente des Eingabearrays) und (die Größe des Zahlenintervalls) ab. Die for-Schleifen werden jeweils -mal oder -mal durchlaufen. Die Zeitkomplexität von Countingsort beträgt somit .