1 Datastructuren Quicksort en andere sorteermethoden College 3.

Slides:



Advertisements
Verwante presentaties
KWALITEITSZORG november 2012
Advertisements

Sudoku puzzels: hoe los je ze op en hoe maak je ze?
‘SMS’ Studeren met Succes deel 1
Wat was toen het grootste het grootste probleem van de van de FOD?
Differentie vergelijkingen differentie vergelijkingen
NEDERLANDS WOORD BEELD IN & IN Klik met de muis
Beter afspelen.
vergelijkingen oplossen
November 2013 Opinieonderzoek Vlaanderen – oktober 2013 Opiniepeiling Vlaanderen uitgevoerd op het iVOXpanel.
Uitgaven aan zorg per financieringsbron / /Hoofdstuk 2 Zorg in perspectief /pagina 1.
Global e-Society Complex België - Regio Vlaanderen e-Regio Provincie Limburg Stad Hasselt Percelen.
 Deel 1: Introductie / presentatie  DVD  Presentatie enquête  Ervaringen gemeente  Pauze  Deel 2 Discussie in kleinere groepen  Discussies in lokalen.
Datastructuren Quicksort
Ronde (Sport & Spel) Quiz Night !
1 Hashtabellen Datastructuren. 2 Dit onderwerp Direct-access-tabellen Hashtabellen –Oplossen van botsingen met “ketens” (chaining) –Analyse –Oplossen.
Een optimale benutting van vierkante meters Breda, 6 juni 2007.
Kb.1 Ik leer op een goede manier optellen en aftrekken
Datastructuren Analyse van Algoritmen en O
Datastructuren Analyse van Algoritmen en O
Nooit meer onnodig groen? Luuk Misdom, IT&T
Hoofdstuk 6: Controle structuren
FOD VOLKSGEZONDHEID, VEILIGHEID VAN DE VOEDSELKETEN EN LEEFMILIEU 1 Kwaliteit en Patiëntveiligheid in de Belgische ziekenhuizen anno 2008 Rapportage over.
Elke 7 seconden een nieuw getal
Datastructuren Onderwerp 10
1 Datastructuren Sorteren: alleen of niet alleen vergelijkingen College 5.
1 Datastructuren Lijstjes (Stacks & Queues) Onderwerp 7.
Fibonacci & Friends Met dank aan Gerard Tel.
Datastructuren Zoekbomen
Zoekbomen: rotaties AVL-bomen Rood-zwart-bomen
1 Datastructuren Heapsort College 4. 2 Vandaag  Kort: ADT vs Datastructuur  Heaps en Heapsort  Tijd over: ondergrenzen voor sorteren; nog sneller sorteren.
1 Datastructuren Zoekbomen II Invoegen en weglaten.
1 Datastructuren Sorteren: alleen of niet alleen vergelijkingen (II) College 6.
Gebalanceerde bomen Zoekbomen: weglaten in rood-zwart-bomen.
Machten en logaritmen Een stukje geschiedenis
Lineaire functies Lineaire functie
Regelmaat in getallen … … …
Regelmaat in getallen (1).
1 het type x² = getal 2 ontbinden in factoren 3 de abc-formule
Parallelle Algoritmen String matching. 1 Beter algoritme patroonanalyse Bottleneck in eenvoudig algoritme: WITNESS(j) (j = kandidaat in eerste i-blok)
Oefeningen F-toetsen ANOVA.
Wat levert de tweede pensioenpijler op voor het personeelslid? 1 Enkele simulaties op basis van de weddeschaal B1-B3.
In dit vakje zie je hoeveel je moet betalen. Uit de volgende drie vakjes kan je dan kiezen. Er is er telkens maar eentje juist. Ken je het juiste antwoord,
1 Datastructuren Skiplists. 2 Skiplists  Vrij eenvoudige datastructuur  “Makkelijker” dan gebalanceerde bomen  Kunnen hetzelfde als gebalanceerde bomen.
1 Optuigen van datastructuren 2 Dynamische order statistics (2)
Optuigen van datastructuren
Datastructuren Sorteren: bubble, merge, quick
1 Datastructuren Heapsort (2e deel) College 5. 2 Vandaag  Heaps en Heapsort  (eind)  Nog sneller sorteren:  Ondergrenzen  Linair sorteren.
Datastructuren Sorteren, zoeken en tijdsanalyse
Seminarie 1: Pythagoreïsche drietallen
1 © GfK 2012 | Supermarktkengetallen | GFK SUPERMARKTKENGETALLEN ‘Hoe ontwikkelt het aantal kassabonnen zich?’ ‘Wat is de omzet van de supermarkten.
Ben Bruidegom 1 Sequentiële schakelingen Toestand uitgang bepaald door:  ingangen;  vorige toestand uitgang.
ribwis1 Toegepaste wiskunde Lesweek 01 – Deel B
ribwis1 Toegepaste wiskunde – Differentieren Lesweek 7
Statistiekbegrippen en hoe je ze berekent!!
Optuigen van datastructuren Datastructuren Onderwerp 11.
Datastructuren Sorteren, zoeken en tijdsanalyse
1 Datastructuren Een informele inleiding tot Skiplists Onderwerp 13.
Hashtabellen Datastructuren. 2 Dit onderwerp Direct-access-tabellen Hashtabellen –Oplossen van botsingen met “ketens” (chaining) –Analyse –Oplossen van.
Sorteeralgoritmen. Sorteren: aanpak 1 Hoe ga je een rij getallen sorteren met PC? Sorteren door selectie (= selection sort): Zoek de kleinste waarde Sorteer.
ECHT ONGELOOFLIJK. Lees alle getallen. langzaam en rij voor rij
Hoofdstuk 9 havo KWADRATEN EN LETTERS
Fractale en Wavelet Beeldcompressie
Intermezzo: Queries op zoekbomen Datastructuren. Queries: hoe op te lossen We hebben: – Een zoekboom (gewoon, rood-zwart, AVL,…) – Een vraag / querie.
1 Datastructuren Quicksort College 3. 2 Vorige keren  O-notaties  Sorteren: insertion sort, bubble sort  Kosten (n 2 ) tijd in het slechtste geval.
1 Datastructuren Sorteren, zoeken en tijdsanalyse College 2.
1 Datastructuren Analyse van algorithmen (vervolg) Heapsort College 4.
Minimum Opspannende Bomen Algoritmiek. 2 Inhoud Het minimum opspannende bomen probleem Een principe om een minimum opspannende boom te laten groeien Twee.
Divide & Conquer: Verdeel en Heers vervolg Algoritmiek.
Minimum Opspannende Bomen
Transcript van de presentatie:

1 Datastructuren Quicksort en andere sorteermethoden College 3

2 Vandaag  Quicksort  Randomized quicksort  Meer over analyse van algoritmen  Heaps en heapsort Datastructuren

3 Quicksort  Verdeel en heers paradigma  Idee is:  Kies een element uit de array, zeg x  Splits de array in drie stukken: Alles in 1 e stuk is  x 2 e stuk is het element x Alles in 3 e stuk is  x (of >)  Sorteer recursief het eerste stuk  Sorteer recursief het derde stuk  Klaar!

4 Opmerking  In onze beschrijving gaan we er van uit dat alle elementen verschillend zijn  Als er gelijke elementen zijn, werkt het ook, maar moet je iets beter opletten in de analyse (zelfde code kan gebruikt worden) Datastructuren

5 PARTITION Quicksort: Eén Datastructuren

6 Splitsen Partition(A,p,r)  {Input is array A met indexwaardes van p tot en met r}  {Output: waarde q met p  q  r zodat A[p..r] een permutatie is van input, en als p  i  q dan geldt A[i] A[q] en als q  i  r dan geldt A[i] A[q]}  …  Methode partitioneert array A[p…r]  Returnwaarde is plek waar “splitselement” terechtgekomen is  Splitselement heet pivot en nemen we nu als element dat op A[r] staat

7 Partition  Code in boek is subtiel pivot Allemaal  Allemaal  Gebied waar we nog aan werken ij-1p r i+1j

8 Pseudocode Partition Partition(A,p,r)  pivot = A[r];  i = p – 1;  for j = p to r – 1 do  {*}  if A[j]  pivot  then i ++; Verwissel A[i] en A[j]  Verwissel A[i+1] en A[r];  return i+1;  Invariant: bij * geldt voor elke k, p  k  r: 1. Als p  k  i, dan A[k]  pivot 2. Als i+1  k  j – 1, dan A[k]  pivot 3. Als k=r, dan A[k]=pivot

9 Pseudocode Partition Partition(A,p,r)  pivot = A[r];  i = p – 1;  for j = p to r – 1 do  {*}  if A[j]  pivot  then i ++; Verwissel A[i] en A[j]  Verwissel A[i+1] en A[r];  return i+1;  Invariant: bij * geldt voor elke k, p  k  r: 1. Als p  k  i, dan A[k]  pivot 2. Als i+1  k  j – 1, dan A[k]  pivot 3. Als k=r, dan A[k]=pivot  Merk op:  Initieel geldt invariant: triviaal  Invariant blijft gelden  Bij terminatie …

10 Partition na de loop  En dan verwisselen we A[i+1] en A[r] Allemaal  Allemaal  i p r i+1 Allemaal  Allemaal  i+1 pr

11 Looptijd partition Partition(A,p,r)  pivot = A[r];  i = p – 1;  for j = p to r – 1 do  {*}  if A[j]  pivot  then i ++; Verwissel A[i] en A[j]  Verwissel A[i+1] en A[r];  return i+1;  Lineair(r-p+1)  Inspectie van loopstructuur

12 CODE EN EERSTE ANALYSE Quicksort: Twee Datastructuren

13 Quicksort Quicksort(A, p, r)  {Sorteert het deel van de array A[p…r]}  if p < r  then  q = Partition(A, p, r)  Quicksort(A, p, q-1)  Quicksort(A, q+1, r)

14 Allemaal  Allemaal  q r r p p

15 Hoeveel tijd kost Quicksort?  In het slechtste geval gaat het erg langzaam…  Bekijk een gesorteerde rij:  We splitsen in stukken van grootte n – 1; 1; 0  En de volgende keer in stukken van grootte n-2; 1; 0  Etc.  Dus: cn+ c(n-1)+ c(n-2)+ c(n-3) + … +3c+2c+c = c n(n+1)/2 stappen  Op een gesorteerde rij: (n 2 ) stappen

16 Analyse met recurrente betrekkingen  Schrijf: T(n) is aantal stappen van Quicksort op gesorteerd array met n elementen  T(n) = T(n-1)+T(0) + (n) = T(n-1)+ (n) = (n 2 ) Andere constantes Met inductie naar n

17 Quicksort voor aartsoptimisten  Als we echt geluk hebben, splitst Quicksort altijd precies middendoor en gaan we in recursie op twee stukken van hooguit n/2 elementen  Zelfde analyse als bij Mergesort geeft (n lg n) tijd

18 log n niveau’s

19 Beste geval analyse van Quicksort met recurrente betrekkingen  Stel T(n) is het beste geval van de looptijd van Quicksort op een array met n elementen  T(n)  2*T(n /2) + O(n) (*)  T(n) = O(n lg n)  Volgt uit (*) met inductie  Zo kan je ook Mergesort analyseren

20 Quicksort voor optimisten (niet noodzakelijk aartsoptimisten)  Stel nu dat we altijd verdelingen hebben die de array splitsen in twee stukken die verhouding 9 – 1 hebben  9/10 e is gewoon een voorbeeld  T(n) = T(9n / 10)+ T(n / 10) + (n)  Recursieboom heeft log 10/9 n = (lg n) lagen  Per laag (n) dus in zo’n geval eveneens (n lg n)  Maar … hoe vaak gebeurt dat?

21 Hoe vaak doen we een goede splitsing?  In 80% van de gevallen splitsen we 9-1 of beter…  Ingewikkelde analyse geeft (n lg n) tijd gemiddeld over alle mogelijke permutaties van input als alle getallen verschillend zijn (doen we niet)

22 RANDOMIZED QUICKSORT Drie Datastructuren

23 Hoe zorgen we ervoor dat we heel vaak goed splitsen  Idee 1: maak eerst een random permutatie van de input  Geeft (n lg n)  Analyse ingewikkeld  Idee 2 (beter): gebruik niet A[r] als pivot, maar gebruik een random element als pivot  Geeft ook (n lg n)  Analyse eenvoudiger  Ietsje sneller

24 Randomized-Partition Randomized-Partition(A,p,r)  Kies uniform een random getal i uit de verzameling {p, p+1, …, r}  Verwissel A[r] en A[i]  Partition(A,p,r) Elk element in A heeft dezelfde kans om als pivot-element gebruikt te worden

25 Randomized-Quicksort pseudocode Randomized-Quicksort(A, p, r)  {Sorteert het deel van de array A[p…r]}  if p < r  then  q = Randomized-Partition(A,p,r)  Randomized-Quicksort(A, p, q-1)  Randomized-Quicksort(A, q+1, r)

26 Analyse Randomized Quicksort  Verschillende manieren om de verwachtte tijd uit te rekenen  Netjes: stel recurrente betrekking op, en los die op (zie o.a. sheets)  Vandaag: telargument waarbij we kijken naar “hoe vaak doet een element mee in een partition”?

27 Maar eerst: slechtste geval  In het slechtste geval:  Net als “gewone” Quicksort: gesorteerde rij, en steeds wordt grootste element als pivot ‘toevallig’ gekozen  Dus O(n 2 ) Datastructuren

28 Tijd is O(som partition-lengtes)  Kijk naar recursieboom  Totale tijd is O(som van alle lengtes van alle deelstukken waar we een partitie op doen)  =  O(som over alle elementen van aantal keren dat het element in een partitie mee doet)

29 Verwachtte tijd  Totale verwachtte tijd is O(verwachte som van alle lengtes van alle deelstukken waar we een partitie op doen)  =  O(som over alle elementen van verwachtte aantal keren dat het element in een partitie mee doet)  = n* O(verwachtte aantal keren dat een element in een partitie meedoet)

30 Afschatten van verwachtte aantal keren dat een element in een partitie meedoet  Is O(log n)  Hoe laten we dit zien?  Kijk element x, en kijk naar het formaat van het stuk waar x in zit.  Begint met formaat n  Iedere keer een beetje kleiner  Als formaat 1 is zijn we klaar  Hoe vaak is het verwachtte aantal keren dat het kleiner wordt? We laten zien: O(log n)

31 Kansberekening  Experiment met kans p op succes, 0<p<1  Wordt r keer uitgevoerd  Verwachting (E) van aantal successen: pr  Verwachtte aantal keren tot 1 e succes: 1/p  Verwachtte aantal keren tot r e succes: r/p Datastructuren

32 Kans is ½ dat stuk hooguit ¾ van oude lengte heeft  Als we een stuk hebben met r elementen zijn er r/2 keuzes voor de pivot die zorgen dat de volgende keer het grootste stuk hooguit ¾ * r lang is

33 Tellerij klaar  Hoe vaak kan je n met ¾ vermenigvuldigen totdat je onder de 1 bent?  log 4/3 n keer = O(log n)  Wat is het verwachtte aantal keren dat je een experiment met kans ½ moet doen totdat je s keer succes hebt?  2s  Dus verwachtte aantal keren dat element in partitie meedoet is hooguit 2 log 4/3 n = O(log n) keer  Dus: verwachtte tijd Quicksort O(n log n)  Andere analyse (wel in sheets, niet vandaag):  2n ln n

34 Analyse Randomized-Partition  Slechtste geval: weer (n 2 )  T(n) = max 0 q n-1 T(q)+T(n-q-1)+(n)  Verwachtte tijd: analyse doen we hier aannemend dat alle elementen verschillend zijn (anders klopt ‘t ook, overigens)  We doen de analyse hier met behulp van de sommatiefactormethode  Eerst: vergelijking looptijd en aantal vergelijkingen Slaan we dit jaar over

35 Looptijd vs aantal vergelijkingen  Stel Quicksort doet X vergelijkingen. Dan gebruikt het O(n+X) tijd  Partition doet altijd minstens 1 vergelijking Want we roepen Partition alleen aan op stukken met minstens 2 elementen  Partition doet O(aantal vergelijkingen in partition) werk  …  We gaan nu het verwachtte aantal vergelijkingen tellen dat Quicksort doet op een array met n verschillende elementen. Noem dit getal C(n)

36 Technisch detail  We volgen de analyse uit Concrete Mathematics. Die gebruikt twee vergelijkingen per recursieve aanroep extra.  Deze waardes noemen we D(n).  D(0)=C(0)=0; als n>0 dan is D(n)>C(n)  Als we dus voor D(n) een bovengrens hebben, geeft dat ook een bovengrens voor C(n)  Uiteindelijke waarde is dus iets beter (scheelt niet veel)

37 Aantal vergelijkingen (Randomized)- Partition Partition(A,p,r)  pivot = A[r];  i = p – 1;  for j = p to r – 1 do  {*}  if A[j]  pivot  then i ++; Verwissel A[i] en A[j]  Verwissel A[i+1] en A[r];  return i+1;  n-1 vergelijkingen op een array met n elementen  Concrete Mathematics neemt hier n+1 vergelijkingen

38 Analyse D(n) (1)  D(0) = 0  D(1) = 2  D(n) = n+1 + ????  Elk van de splitsingen heeft dezelfde kans: 0,1,n-1 1,1,n-2 2,1,n-3 … n-2, 1, 1 n-1, 1, 0

39 Analyse D(n) (2)  D(0)= 0  D(1)= 2  D(n) = n+1 + 1/n* k=0 n-1 D(k) + 1/n* k=0 n-1 D(n-k- 1)  Elk van de splitsingen heeft dezelfde kans: 0,1,n-1 1,1,n-2 2,1,n-3 … n-2, 1, 1 n-1, 1, 0  Of: D(n) = n+1 + (2/n)* k=0 n-1 D(k) voor n>0

40 - Deze hadden we Maal n nemen Zelfde vergl. voor n-1 Vergelijkingen aftrekken Na vereenvoudigen

41 Stelsel vergelijkingen  D(0)=0  nD(n) = (n+1)D(n-1)+ 2n  Dit stelsel kunnen we met sommatiefactormethode oplossen  Idee is: vermenigvuldig formule met sommatiefactor s n waarbij s n = (a n-1 a n-2 …a 1 )/(b n b n-1 …b 2 ) als a n D(n)=b n D(n-1)+c n Want dan is s n b n =s n-1 a n-1 En dan krijg je voor E(n)=s n a n D(n) de formule E(n)=E(n-1)+s n c n Wat een somformule voor E en daarna voor D geeft…

42 D(0)=0 nD(n) = (n+1)D(n-1)+ 2n a n = n b n = n+1 c n = 2n : dit hadden we Definitie toepassen: Alles maal s n : Def.: (*) en (**) geven: (*) (**)

43 dus We hadden dus Want E(0)=0

44 Aantal vergelijkingen randomized quicksort Randomized-Quicksort doet verwacht ongeveer 2(n+1)ln n vergelijkingen

45 Nieuw onderzoek  Recent werk: quicksort met meer dan 1 pivotelement... Is soms nèt iets sneller  “Dual Pivot Quicksort” Datastructuren

46 ADT versus Datastructuur  Datastructuur  is een systematische manier van organiseren van data en toegang verlenen tot diezelfde data.  Abstract data type  is een model van een datastructuur waarin gespecificeerd is: type van de data operaties ter ondersteuning van de datastructuur de types van de parameters van deze operaties  Een abstract data type concentreert zich op functionaliteit, niet op tijd.  Vandaag: Heap (is ADT), Array-implementatie van Heap Datastructuren

47 Heap  “Hoop”, zoals in “een steenhoop”  Datastructuur, gebruikt voor sorteren en priority queue  Een heap is eigenlijk een boom, maar kan heel efficient in een array worden weergegeven  Datastructuren voor “echte” bomen komen later

48 Heap  “Bijna volledige binaire boom”  Vervult de “heap-eigenschap”  Wat bedoelen we hiermee?

49 Binaire boom  Binaire boom:  Iedere knoop heeft 0, 1 of 2 kinderen  Volledige binaire boom:  Behalve op het onderste niveau heeft elke knoop 2 kinderen  Een knoop kan hebben:  Ouder (PARENT)  Linkerkind (LEFT)  Rechterkind (RIGHT)

50 Bijna volledige binaire boom  Alle niveau’s helemaal gevuld, behalve ‘t onderste dat een eindje van links af gevuld is, en daarna niet meer  Volledige bb mag ook

51 Twee termen  Diepte van knoop: afstand naar wortel  Hoogte van knoop x: maximale afstand naar blad onder x

52 Heap-eigenschap  Elke knoop x in de heap heeft een waarde A[x]  Max-heap eigenschap: voor alle knopen i (behalve natuurlijk de wortel van de boom) geldt: A[PARENT(i)]  A[i]  Min-heap eigenschap: voor alle knopen i (behalve natuurlijk de wortel van de boom) geldt: A[PARENT(i)] A[i]

Max-heap

54 Heapsort  Gebruikt de Heap datastructuur met implementatie in array  Heap

55 Implementatie van een heap

56 Implementatie van een heap  Gebruik een array  A[1] is de wortel  A[2], A[3] de achteenvolgende elementen op hoogte 1  A[4], A[5], A[6], A[7] voor hoogte 2,  A[2 r ], … A[2 r+1 -1] voor hoogte r  PARENT(i)  Return  i/2   LEFT(i)  Return 2i;  RIGHT(i)  Return 2i+1;

57 Array implementatie  PARENT(i)  Return  i/2   LEFT(i)  Return 2i;  RIGHT(i)  Return 2i+1;

58 “Operaties” op Max-Heap  Build-Max-Heap  Maak een heap van een ongeordende array elementen  Max-Heap-Insert  Voeg een nieuw element toe aan een heap  Heap-Extract-Max  Haal het grootste element uit de heap en lever dat op  Heap-Increase-Key  Verhoog de waarde van een element  Heap-Maximum  Lever de waarde van het grootste element op (zonder iets te veranderen)  NB: Notatie boek is wat slordig (verwart ADT en implementatie, maar ik volg ‘m toch)

59 Min-heaps  Net als Max-heaps met min en max (etc.) omgedraaid

60 Als we deze operaties geimplementeerd hebben, kunnen we sorteren  Build-Max-Heap(A)  For i=0 to n-1 do  B[n-i] = Heap-Extract-Max(A)

61 Belangrijke subroutine: Max-Heapify  Max-heapify(A,i)  {Input-aanname: de binaire boom met wortel LEFT(i) en de binaire boom met wortel RIGHT(i) zijn max-heaps}  {Output: permutatie, zodat de binaire boom met wortel i is een max-heap}

Idee: als i groter (  ) is dan beide kinderen: OK, klaar Anders, verwissel met grootste kind en ga dan corrigeren op de plek van ‘t grootste kind

64 Max-heapify Max-Heapify(A,i)  links = LEFT(i)  rechts = RIGHT(i)  if (links  heap-size[A] and A[links] > A[i])  then grootste = links  else grootste = i  if (rechts  heap-size[A] and A[rechts] > A[grootste])  then grootste = rechts  if (grootste  i)  then  Verwissel A[i] en A[grootste]  Max-Heapify(A,grootste)

65 Analyse Max-Heapify  Correct?  Looptijd: O(diepte van i)  De diepte van een knoop is nooit meer dan log n, als heap-size(A)=n  Dus: O(log n)

66 Build-Max-Heap Build-Max-Heap(A)  {Input: ongesorteerde rij getallen A[1…lengte(A)]}  {Output: A is een permutatie van input die aan max-heap eigenschap voldoet}

67 Build-Max-Heap Build-Max-Heap(A)  {Input: ongesorteerde rij getallen A[1…lengte(A)]}  {Output: A is een permutatie van input die aan max-heap eigenschap voldoet}  heap-size[A] = lengte(A);  for i=  lengte(A)/2 downto 1 do  Max-Heapify(A,i) That’s all en ‘t klopt ook nog! That’s all en ‘t klopt ook nog!

68 Correctheid Build-Max-Heap  Invariant: aan het begin van de for-loop is elke knoop i+1, … n de wortel van een max-heap  Initieel: klopt, want boompjes van 1 knoop  Onderweg: vanwege Max- Heapify… (bespreken details)  Terminatie: leuk, want i=0, dus knoop 1 is wortel van max-heap, dus hele array is max-heap for i=  lengte(A)/2  downto 1 do Max-Heapify(A,i)

69 Tijdsanalyse Build-Max-Heap  Eenvoudige analyse geeft O(n log n)  Voor iedere i tussen 1 en n/2 doen we O(log n) werk  Meer precieze analyse geeft O(n)  Werk voor knoop i is O(hoogte(i))  De hoogte van de boom is  log n (basis 2)  Er zijn n h+1 knopen met hoogte h in de boom  Gebruik dat Details op bord

70 Heapsort  Build-Max-Heap(A)  for i = lengte(A) downto 2 do  {A[1] is het maximum}  {A[1…heap-size[A]} is een heap, de elementen na heap-size[A] zijn gesorteerd maar niet langer in de heap}  {Invariant: i = heapsize[A]}  Verwissel A[1] en A[i];  Heapsize[A] --;  Max-Heapify[A];

71 Analyse  Correct, want …  O(n log n) tijd want…

72 Next:  Andere operaties op heaps ...