Heap sort is een vergelijkingsgebaseerde sorteertechniek gebaseerd op Binary Heap datastructuur. Het is vergelijkbaar met selection sort waar we eerst het maximum element vinden en het maximum element aan het eind plaatsen. We herhalen hetzelfde proces voor de resterende elementen.
Wat is Binary Heap?
Laten we eerst een complete binaire boom definiëren. Een complete binaire boom is een binaire boom waarin elk niveau, behalve mogelijk het laatste, volledig is gevuld, en alle knooppunten zo ver mogelijk naar links staan (Bron Wikipedia)
Een binaire hoop is een complete binaire boom waarin items zijn opgeslagen in een speciale volgorde, zodanig dat de waarde in een ouder knooppunt groter (of kleiner) is dan de waarden in zijn twee kinderen knooppunten. De eerste wordt max-heap genoemd en de tweede min-heap. De heap kan worden gerepresenteerd door een binaire boom of een array.
Waarom een array-gebaseerde representatie voor Binary Heap?
Omdat een binaire hoop een complete binaire boom is, kan hij gemakkelijk worden weergegeven als een matrix en de op een matrix gebaseerde weergave is ruimte-efficiënt. Als de ouder node is opgeslagen op index I, kan het linker kind worden berekend door 2 * I + 1 en het rechter kind door 2 * I + 2 (ervan uitgaande dat de indexering begint bij 0).
Heap Sort Algoritme voor sorteren in oplopende volgorde:
1. Bouw een max heap van de invoergegevens.
2. Op dit punt wordt het grootste item opgeslagen aan de wortel van de hoop. Vervang het door het laatste item van de heap, gevolgd door het verkleinen van de heap met 1. Tot slot, heap de wortel van de boom.
3. Herhaal stap 2 zolang de grootte van de heap groter is dan 1.
Hoe bouw je de heap op?
De heapify procedure kan alleen op een knoop worden toegepast als zijn kinderen ook geheapificeerd zijn. Dus de heapificatie moet worden uitgevoerd in de volgorde van onder naar boven.
Laten we dit begrijpen met behulp van een voorbeeld:
Input data: 4, 10, 3, 5, 1 4(0) / \ 10(1) 3(2) / \ 5(3) 1(4)The numbers in bracket represent the indices in the array representation of data.Applying heapify procedure to index 1: 4(0) / \ 10(1) 3(2) / \5(3) 1(4)Applying heapify procedure to index 0: 10(0) / \ 5(1) 3(2) / \ 4(3) 1(4)The heapify procedure calls itself recursively to build heap in top down manner.
#include <iostream>usingnamespacestd; voidheapify(intarr, intn, inti) { intlargest = i; intl = 2 * i + 1; intr = 2 * i + 2;
if(l < n && arr > arr) largest = l;
if(r < n && arr > arr)
largest = r;
if(largest != i) {
swap(arr, arr); heapify(arr, n, largest); }
}voidheapSort(intarr, intn) { for(inti = n / 2 - 1; i >= 0; i--) heapify(arr, n, i);
for(inti = n - 1; i > 0; i--) { swap(arr, arr); heapify(arr, i, 0); } }voidprintArray(intarr, intn) { for(inti = 0; i < n; ++i) cout << arr << " "; cout << "\n"; }intmain() { intarr = { 12, 11, 13, 5, 6, 7 }; intn = sizeof(arr) / sizeof(arr);
heapSort(arr, n); cout << "Sorted array is \n"; printArray(arr, n); }publicclassHeapSort { publicvoidsort(intarr) {
intn = arr.length;
for(inti = n / 2- 1; i >= 0; i--) heapify(arr, n, i);
for(inti = n - 1; i > 0; i--) {
inttemp = arr; arr = arr; arr = temp;
heapify(arr, i, 0);
} } voidheapify(intarr, intn, inti)
{ intlargest = i;
intl = 2* i + 1; intr = 2* i + 2; if(l < n && arr > arr)
largest = l; if(r < n && arr > arr)
largest = r; if(largest != i) {
intswap = arr; arr = arr; arr = swap;
heapify(arr, n, largest); } } staticvoidprintArray(intarr) { intn = arr.length; for(inti = 0; i < n; ++i)
System.out.print(arr + " "); System.out.println(); } publicstaticvoidmain(String args) { intarr = { 12, 11, 13, 5, 6, 7}; intn = arr.length;
HeapSort ob = newHeapSort(); ob.sort(arr); System.out.println("Sorted array is"); printArray(arr);
} }defheapify(arr, n, i): largest =i l =2*i +1 r =2*i +2 ifl < n andarr < arr: largest =l
ifr < n andarr < arr: largest =r iflargest !=i: arr, arr =arr, arr heapify(arr, n, largest) defheapSort(arr): n =len(arr) fori inrange(n//2-1, -1, -1): heapify(arr, n, i)
fori inrange(n-1, 0, -1): arr, arr =arr, arr heapify(arr, i, 0) arr =heapSort(arr)n =len(arr) print("Sorted array is") fori inrange(n): print("%d"%arr),
usingSystem; publicclassHeapSort { publicvoidsort(int arr) { intn = arr.Length; for(inti = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i); for(inti = n - 1; i > 0; i--) { inttemp = arr; arr = arr; arr = temp; heapify(arr, i, 0); } } voidheapify(int arr, intn, inti) { intlargest = i; intl = 2 * i + 1; intr = 2 * i + 2; if(l < n && arr > arr) largest = l; if(r < n && arr > arr) largest = r; if(largest != i) { intswap = arr; arr = arr; arr = swap; heapify(arr, n, largest); } } staticvoidprintArray(int arr) { intn = arr.Length; for(inti = 0; i < n; ++i) Console.Write(arr + " "); Console.Read();
} publicstaticvoidMain() { int arr = { 12, 11, 13, 5, 6, 7 }; intn = arr.Length; HeapSort ob = newHeapSort(); ob.sort(arr); Console.WriteLine("Sorted array is"); printArray(arr); } }
<?phpfunctionheapify(&$arr, $n, $i) { $largest= $i; $l= 2*$i+ 1;
$r= 2*$i+ 2; if($l< $n&& $arr > $arr) $largest= $l;
if($r< $n&& $arr > $arr) $largest= $r;
if($largest!= $i) {
$swap= $arr;
$arr = $arr; $arr = $swap; heapify($arr, $n, $largest); } }functionheapSort(&$arr, $n) { for($i= $n/ 2 - 1; $i>= 0; $i--) heapify($arr, $n, $i); for($i= $n-1; $i> 0; $i--) {
$temp= $arr; $arr = $arr; $arr = $temp; heapify($arr, $i, 0); }
}functionprintArray(&$arr, $n) { for($i= 0; $i< $n; ++$i) echo($arr." ") ;
} $arr= array(12, 11, 13, 5, 6, 7); $n= sizeof($arr)/sizeof($arr); heapSort($arr, $n); echo'Sorted array is '. "\n"; printArray($arr, $n);
?>Sorted array is 5 6 7 11 12 13
Hier is eerdere C code ter referentie.
Noten:
Heap sort is een in-place algoritme.
De typische implementatie is niet stabiel, maar kan stabiel gemaakt worden (Zie dit)
Tijd complexiteit: Tijdscomplexiteit van heapify is O(Logn). Tijdscomplexiteit van createAndBuildHeap() is O(n) en de totale tijdscomplexiteit van Heap Sort is O(nLogn).
Toepassingen van HeapSort
1. Een bijna gesorteerde (of K gesorteerde) array sorteren
2. k grootste (of kleinste) elementen in een array
Heap sort algoritme heeft beperkte toepassingen omdat Quicksort en Mergesort in de praktijk beter zijn. Niettemin wordt de Heap datastructuur zelf enorm veel gebruikt. Zie Toepassingen van Heap datastructuur
https://youtu.be/MtQL_ll5KhQ
Snapshots:
Quiz over Heap Sort
Andere sorteeralgoritmen op GeeksforGeeks/GeeksQuiz:
QuickSort, Selection Sort, Bubble Sort, Insertion Sort, Merge Sort, Heap Sort, QuickSort, Radix Sort, Counting Sort, Bucket Sort, ShellSort, Comb Sort, Pigeonhole Sort
Coding practice voor sorteren.