Wie ein Heapsort Java verwendet

February 22

Der Heapsort-Algorithmus ist eine der am schnellsten Sortieralgorithmen verfügbar. Programmierer verwenden Heapsort Java, denn es eine gute Wahl für sehr große Arrays, die sie kennen ist, in einer unsortierten Zustand sein. Der Effizienz halber keine tatsächlichen Baumstruktur verwendet. Stattdessen wird der Baum gebildet im Ort, direkt im Array. Der Heapsort-Algorithmus ist ein Algorithmus "in Place", wie es keine zusätzlichen Speicher erfordert um die Sortierung durchzuführen.

Anweisungen

1 Richten Sie die Swap-Methode. Diese tauschen Sie zwei Elemente eines Arrays.""public static void swap(int[] a, int i, int j) { int tmp = a[j]; a[j] = a[i]; a[i] = tmp; }""

2 Schreiben Sie den Kern des Algorithmus, der SiftDown-Methode. Es wird verwendet, um sowohl bilden die Heapstruktur und die tatsächliche Art zu tun.

3 Sieben Sie große Werte in Richtung der Wurzel des Baumes und kleine Werte in Richtung der Blätter mit der SiftDown-Methode. Wie diese Methode mehrmals während das Sortierverfahren genannt wird, ist der größte Knoten konsequent zum Stammknoten gesiebt und zog am Ende des Arrays. N Knoten hat bis zu zwei Kinder, deren Indizes n 2 + 1 und n 2 + 2 sind.""public static void siftDown(int[] a, int start, int end) { int root = start;

while( root 2 + 1 <= end ) { int child = root 2 + 1;

// If the child has a sibling and the child's value is less than its sibling if( child < end && a[child] < a[child + 1] ) { child++; }

if( a[root] < a[child] ) { swap(a, root, child); root = child; } else { return; } } }""

4 Verwenden Sie die Heapify-Methode. Diese Methode nennt sich am Anfang von der Art die anfänglichen Heapstruktur zu erstellen. Dies geschieht schnell, da die Heapstruktur etwas vage ist. Die einzige Voraussetzung ist, dass jeder Root-Knoten untergeordneten Knoten größer sein muss.""public static void heapify(int[] a) { for( int start = a.length / 2--1; start >= 0; start-- ) siftDown(a, start, a.length-1); }""

5 Schreiben Sie die HeapSort-Methode. Die Methode heapifies zuerst das Array für die Sortierung vorzubereiten. Die SiftDown-Methode wird dann erneut aufgerufen, da Knoten nun ein kleiner Wert ist. Das siebt einen neuen großen Wert auf den Stammknoten, und der gesamte Prozess wird wiederholt, bis die Größe des Heaps gehört.""public static void heapSort(int[] a) { heapify(a);

for( int end = a.length--1; end > 1; end--) { swap(a, end, 0); siftDown(a, 0, end--1); } }""

6 Testen Sie die HeapSort-Methode. Das folgende Beispiel zeigt ein kleines Testprogramm.""public static void main(String[] args) { int[] a = new int[10];

for( int i = 0; i < 10; ++i ) a[i] = i+1; for( int i = 0; i < 10; ++i ) swap(a, i, i + (int) (Math.random() * (9--i)));

System.out.println("Before sorting:"); for( int i = 0; i < a.length; ++i ) System.out.println(a[i]);

heapSort(a); System.out.println("After sorting"); for( int i = 0; i < a.length; ++i ) System.out.println(a[i]); }""

Tipps & Warnungen

  • Obwohl Heapsort nicht verwendet, so oft in Java als Quicksort (da Quicksort ist durchschnittlich schneller), der Heapsort hat ein schneller Worst-Case-Szenario. Wo der Quicksort schlimmstenfalls O(n^2), ist Heapsort im schlimmsten Fall O (n
  • Log(n)).
  • Da die SiftDown-Methode die höchsten Werte an die Spitze des Heaps (Arrayindex 0) siebt, bei jeder Iteration der Sortierung der Stammknoten der letzten Blattknoten zweifelsfrei, und die Größe des Heaps wird verringert. Dies ist, wie die jeweilige Sortierung erfolgt, sieben große Werte nach oben und sie bis zum Ende zu verschieben.
  • Mit einer tatsächlichen Baumstruktur würde eine Menge neuer Objekte zu generieren, laden über die Zuweisung und Garbage Collection, mehr Arbeitsspeicher verwalten und weitere Speicherzugriffe.