Heapsort: verschil tussen versies

Verwijderde inhoud Toegevoegde inhoud
JAnDbot (overleg | bijdragen)
k robot Erbij: is:Hrúguröðun Anders: zh:堆積排序
kGeen bewerkingssamenvatting
Regel 1:
[[Heapsort]] is een snel [[sorteeralgoritme]], ontwikkeld in 1964 door Robert W. Floyd en J. W. J. Williams. Het probeert, net zoals [[straight selection sort]], het grootste element van de te sorteren rij te zoeken, dit achteraan te plaatsen en zo met een minder verder te gaan tot alles op volgorde staat. Het algoritme is bijzonder efficiënt in geheugengebruik, maar is niet [[stabiliteit (sorteeralgoritme)|stabiel]]. <!--''Wat is dit in G-naam?'' Hierbij vormt het algoritme uit de te sorteren elementen een [[heap|max-heap]].-->
 
=== Sortering vanuit een heap= ==
 
''Zie{{zie ook|zie het artikel [[heap]] voor meer informatie over de heap-datastructuur.''}}
===Sortering vanuit een heap===
 
''Zie het artikel [[heap]] voor meer informatie over de heap-datastructuur.''
 
Het idee achter sortering door middel van heapsort is eigenlijk heel eenvoudig:
Regel 16 ⟶ 14:
Om dit algoritme uit te kunnen voeren, is het alleen maar nodig om een heap te kunnen maken uit een rij van elementen.
 
=== Het maken van een heap= ==
 
Zoals te lezen valt in het artikel [[heap]], is het niet nodig om je in allerlei bochten te wringen om een heap te maken – een heap is dan in principe wel een boomstructuur, maar hij kan daarom toch prima opgeslagen worden in een rij (zoals een [[array]]). Als je je maar aan de heap-regel houdt.
Regel 69 ⟶ 67:
]|
 
=== De eerste heap= ==
Het grootste gedeelte van het probleem hebben we nu opgelost. Als we twee heaps hebben, kunnen we ze met een wortel verbinden en de heap-regel herstellen. Zo kunnen we het heapsort algoritme uitvoeren door een heap te pakken en de wortel in de gesorteerde rij te zetten (de wortel is immers altijd het element met de hoogste waarde in de heap). Daarna moeten we beslissen wat de nieuwe wortel gaat worden.
 
Regel 122 ⟶ 120:
]|
 
=== Een kleine optimalisatie= ==
 
Het bovenstaande is correct, maar het maakt wel onnodig gebruik van een extra rij B. In iedere slag van het algoritme wordt namelijk precies een element definitief gesorteerd en valt dus weg uit A – dat betekent dat A altijd precies evenveel ruimte open heeft staan als er gesorteerde elementen zijn. Dus kunnen we de gesorteerde rij net zo goed meteen in A opslaan.
Regel 163 ⟶ 161:
]|
 
=== Efficiëntie= ==
 
Heapsort is een vrij efficiënt algoritme, zowel qua ruimtegebruik als qua [[complexiteitsgraad|orde van looptijd]].
Regel 171 ⟶ 169:
De looptijd wordt bepaald door de aanroepen van MaakHeap en de doorlooptijd daarvan. De doorlooptijd van MaakHeap is lineair in de hoogte van de heap (de lengte van het langste pad van de wortel naar een blad). De heap is een binaire boom, dus de hoogte is van de boom is O(<sup>2</sup>log(N)), waarmee MaakHeap logaritmisch is in complexiteit. MaakHeap wordt in het hoofdalgoritme een keer aangeroepen voor ieder element van de invoerrij, waarmee de totale complexiteit uitkomt op O(N*<sup>2</sup>log(N)). Merk op dat het opbouwen van de initiële heap hier niets aan verandert. Ook hiervoor geldt dat de hoofdloop lineair is en de aanroepen van MaakHeap logaritmisch. Sterker nog, omdat er voor ieder hoogteniveau in de boom een maximaal aantal knopen is, kan zelfs vastgesteld worden dat de eerste opbouw van de heap lineaire tijd vergt en dus efficiënter is dan het hoofdalgoritme.
 
=== Een programmavoorbeeld= ==
 
Een implementatie in C:
Regel 195 ⟶ 193:
</pre>
 
=== alternatief -- iteratief ===
----
 
=== alternatief -- iteratief ===
==== Sortering door middel van heaps= ===
 
De sorteermethode van heapsort is gebaseerd op een oplossing van:
Regel 222 ⟶ 218:
<math>Heap.A=\langle\forall i,j : i=j \mathbf{div}2 : geordend.(A.i,A.j) \rangle </math>
 
==== Het maken van een Heap uit elementen in willekeurige volgorde= ===
 
Men voege een nieuw element toe aan het eind van de rij die de heap bevat en confronteert het met het
Regel 231 ⟶ 227:
Daar 0 DIV 2 = 0 en een totale ordening o.a. reflexief is geldt geordend(A.0,A.0).
Als we het onderste element van de heap altijd index 0 geven vereenvoudigt dit het programma:
 
 
 
{ vereist : Heap.A[0:n) }
Regel 249 ⟶ 243:
HeapIn vanuit een lege Heap gemaakt worden.
 
==== Het produceren van elementen uit een Heap in de voorgeschreven volgorde= ===
 
Het te leveren element is A.0.
Regel 280 ⟶ 274:
]|
 
==== Toepassingen= ===
 
Een groot voordeel van dit mechanisme is dat (bijna) de helft van het sorteren geschiedt
Regel 298 ⟶ 292:
aantal wachtende activiteiten is).
 
==== In-situ sorteren= ===
 
Als een tabel met elementen in snel geheugen reeds bestaat en deze gesorteerd moet worden,
Regel 328 ⟶ 322:
Het eerste deel van de slotconditie is geen kunst, het tweede was de opdracht.
 
[[Categorie:Sorteeralgoritme]]