Seminarium 13 Innehåll Prioritetsköer och heapar Prioritetsköer ADTn Klassen PriorityQueue i java.util Implementering med lista Heapar ADTn För implementering av prioritetskö För sortering Efter seminariet ska du kunna lösa uppgifterna till och med kapitel 12 i övningshäftet EDAA30 (Seminarium 13) HT 2015 1 / 38
Prioritetsköer och heapar Exempel på vad du ska kunna Redogöra för vilka operationer som skall finnas i den abstrakta datatypen prioritetskö. Redogöra för olika sätt att implementera en prioritetskö och kunna jämföra dem med avseende på tidskomplexitet. Använda klassen java.util.priorityqueue Förklara begreppet heap Förklara hur en heap kan implementeras med hjälp av en vektor Förklara hur insättning, borttagning och sökning efter högst prioriterat element går till i en heap och ange dessa metoders tidskomplexitet. Förklara hur man bygger en heap på linjär tid från en osorterad samling Redogöra för algoritmen Heapsort och dess värstafallstid. EDAA30 (Seminarium 13) HT 2015 2 / 38
Prioritetskö Vanlig kö bevarar tidsordning Borttagning avser alltid äldsta elementet. Prioritetskö det viktigaste först Ex: processer som köar för att få tillgång till CPU i dator Ex: väntande patienter på en akutmottagning Prioritetsköer används också som hjälpmedel i vissa algoritmer. Ex: sortering återkommer vi till Ex: grafalgoritmer (kortaste väg m.m.) ingår i en följande kurs EDAA30 (Seminarium 13) HT 2015 3 / 38
ADT Prioritetskö En prioritetskö är en samling element för vilka jämförelse är definierad. Elementen innehåller ett eller flera attribut som modellerar elementets prioritet. Jämförelser baseras på prioriteten. Ex: Personer som väntar på en akutmottagning kan beskrivas av en klass som innehåller ett heltalsattribut som anger prioritet. Många element kan ha samma prioritet. I en prioritetskö ska finnas operationer för att sätta in element. ta reda på det högst prioriterade elementet. ta bort det högst prioriterade elementet. EDAA30 (Seminarium 13) HT 2015 4 / 38
Interface för Prioritetskö I Java finns inget speciellt interface för prioritetsköer. Man använder interfacet Queue<E>. En konkret klass PriorityQueue<E> implementerar Queue<E>: public class PriorityQueue<E> implements Queue<E> { boolean offer(e x) {...} E peek() {...} E poll() {...}... } Konvention: lågt värde på prioritetsattribut anger hög prioritet. peek() returnerar minsta elementet i kön. poll() tar bort och returnerar minsta elementet i kön. EDAA30 (Seminarium 13) HT 2015 5 / 38
Klassen PriorityQueue i java.util Det finns flera konstruktorer, bl. a.: 1 PriorityQueue() 2 PriorityQueue(int initialcapacity, Comparator<? super E> c) Den första konstruktorn förutsätter att elementen implementerar Comparable, annars genereras ClassCastException. Används den andra konstruktorn jämförs elementen med hjälp av komparatorn c. EDAA30 (Seminarium 13) HT 2015 6 / 38
Prioritetskö - implementering Lista sorterad eller osorterad Om sorterad: peek och poll blir O(1) offer blir O(n) rätt plats för elementet måste letas upp Om osorterad: peek och poll blir O(n) minsta element måste letas upp offer blir O(1) elementet kan sättas in först Heap ger effektivare operationer EDAA30 (Seminarium 13) HT 2015 7 / 38
Heap Definition Heap En heap är ett komplett binärt träd där varje nod innehåller ett element som är barnens element. Trädet har alltså formen För varje delträd gäller att roten innehåller det minsta elementet. EDAA30 (Seminarium 13) HT 2015 8 / 38
Heap Exempel och motexempel 2 2 2 3 6 3 6 5 6 5 7 5 7 3 7 Heap Ingen heap. Fel form, men korrekt ordning Ingen heap. Rätt form men ej korrekt ordning EDAA30 (Seminarium 13) HT 2015 9 / 38
Heap Representation En heap kan med fördel lagras i en vektor. Roten finns på plats 0. Barnen till noden på plats i finns på platserna 2i + 1 och 2i + 2 i vektorn. Noden på plats i har alltså sin förälder på plats (i 1)/2. 2 3 6 2 3 6 5 7 0 1 2 3 4 5 7 EDAA30 (Seminarium 13) HT 2015 10 / 38
Implementering av PriorityQueue public class PriorityQueue<E> implements Queue<E> { private E[] queue; private int size;... konstruktorer... } boolean offer(e x) {...} E peek() {...} E poll() {...}... EDAA30 (Seminarium 13) HT 2015 11 / 38
offer Implementering Nya elementet placeras på första lediga plats i vektorn. Detta ger rätt form på trädet. Sedan byten uppåt tills rätt ordning. Kallas percolate up eller addleaf. Ex: Sätt in element med nyckel 1 i heapen: 2 3 6 2 3 6 5 7 5 7 EDAA30 (Seminarium 13) HT 2015 12 / 38
offer Implementering, forts 2 2 Byt! 1 Klart! 3 6 3 1 3 2 5 7 1 5 7 6 5 7 6 Byt! 2 3 6 5 7 1 2 3 1 5 7 6 1 3 2 5 7 6 EDAA30 (Seminarium 13) HT 2015 13 / 38
offer Tidskomplexitet Eftersom en heap är ett komplett binärt träd så gäller h log n där n är antal noder och h är höjden. Den nya noden kan i värsta fall behöva jämföras (och bytas) med alla element på vägen upp till roten. De är h st. Således är antalet jämförelser i värsta fall log n. I medeltal blir det inte så många byten. Man har visat att det blir O(1) byten i medelfall. EDAA30 (Seminarium 13) HT 2015 14 / 38
peek Implementering peek: Minsta element finns på plats 0 i vektorn! Blir O(1)-operation. EDAA30 (Seminarium 13) HT 2015 15 / 38
poll Implementering Tag bort noden på plats 0 i vektorn. Ersätt med den som finns på sista plats. Ger rätt form, men roten har nu troligtvis fel storleksförhållande till sina barn. Byt med minsta av barnen tills ordningen ok. Kallas percolate down eller addroot. Ex: Utför poll() på: 1 3 4 1 3 4 5 7 6 5 7 6 EDAA30 (Seminarium 13) HT 2015 16 / 38
poll Implementering, forts Byt med minsta av barnen! Byt med minsta av barnen! Klart! 6 3 3 3 4 6 4 5 4 5 7 5 7 6 7 6 3 4 5 7 3 6 4 5 7 3 5 4 6 7 EDAA30 (Seminarium 13) HT 2015 17 / 38
poll Tidskomplexitet I värsta fall får jämförelse med barnen och byten upprepas ända ner till ett löv. Värstafallskostnad för poll blir således O(log n). Eftersom det är en nod långt nedifrån (och alltså sannolikt en nod med ett stort element) i trädet som sätts in i roten och byts nedåt så kommer bytena ofta att behöva fortsätta ända ned till ett löv. Medelfallet kan också visas vara O(log n). EDAA30 (Seminarium 13) HT 2015 18 / 38
Bygga heap från osorterad samling Ibland vill man kunna bygga en prioritetskö av en samling osorterade element. Ett sätt är att sätta in elementen i samlingen i en från början tom kö: skapa tom prioritetskö q för varje element, x, i samlingen q.offer(x) Detta koster O(n log n) om det är n element i samlingen. Det går att göra effektivare om man kan arbeta direkt med den vektor (heap) som representerar prioritetskön. EDAA30 (Seminarium 13) HT 2015 19 / 38
Bygga heap från osorterad samling Ny konstruktor i klassen PriorityQueue Lägg till en konstruktor i klassen PriorityQueue: PriorityQueue(Collection<? extends E> c) { queue =...; // skapa en vektor, med tillräcklig storlek /* Lägg över alla element ur c i vektorn queue */ int i = 0; for(e e : c) { queue[i] = e; i++; } size = c.size(); } heapify(); // hjälpmetod, se nästa bild EDAA30 (Seminarium 13) HT 2015 20 / 38
Hjälpmetoden heapify heapify() bygger en heap (på plats) av en osorterad vektor. Idén är att bygga om det träd vektorn representerar till en heap nedifrån och upp. Ex: Utgå från följande vektor: 90 150 130 10 80 20 Bygg en heap på plats i vektorn genom att utföra percolate down med början på den nod som finns på plats n/2 1 sedan på plats n/2 2,..., 0. 90 150 130 10 80 20 Börja alltså med percolate down på detta delträd! EDAA30 (Seminarium 13) HT 2015 21 / 38
Hjälpmetoden heapify Forts Fortsätt med percolate down här! 90 150 20 10 80 130 Sedan percolate-down på roten, som efter byte (i detta fall med vänster barn) innebär att vi eventuellt måste fortsätta med underträd precis som i poll. 90 10 10 10 20 90 20 80 20 150 80 130 150 80 130 150 90 130 EDAA30 (Seminarium 13) HT 2015 22 / 38
heapify - tidskomplexitet I heapify börjar vi på den näst nedersta nivån i trädet och ser till att dessa underträd blir heapordnade. Dessa träd har maximalt höjden 1 och det blir maximalt ett byte i vardera underträd. Sedan fortsätter vi på nivån över. Här finns färre noder, men underträden har maximalt höjden 2. De utför vardera därför maximalt 2 byten etc. Ju högre upp i trädet desto färre noder men desto fler byten nedåt i värsta fall. Man kan visa att heapify kostar O(n) där n är antalet element i vektorn. EDAA30 (Seminarium 13) HT 2015 23 / 38
heapify - tidskomplexitet Forts Jämför med att bygga heapen med successiva offer: offer sätter in elementet sist i vektorn (längst ned i trädet) och därefter sker byten uppåt tills trädet är heapordnat. Tidiga insättningar på låga nivåer i trädet kan maximalt behöva flyttas färre steg uppåt än senare insättningar längre ned i trädet. Det är också färre noder på nivåer nära roten än på nivåer längre från roten, d.v.s. här riskerar många noder långa bytesskedjor. EDAA30 (Seminarium 13) HT 2015 24 / 38
heapify - implementering Koden för heapify blir enkel: private void heapify() { for (int i = (size - 2) / 2; i >= 0; i--) { percolatedown(i); } } Sista elementet finns på plats size 1 i vektorn dess förälder finns på plats (size 2)/2. percolatedown(k) en metod som med start på noden på plats k i vektorn utför byten nedåt i heapen så länge ordningen är felaktig. (Denna metod används även av operationen poll.) EDAA30 (Seminarium 13) HT 2015 25 / 38
Effektiv sortering med hjälp av prioritetskö Sorteringsidé, för att sortera en vektor a: PriorityQueue<E> myq = new PriorityQueue<E>(); for (int i = 0; i < a.length; i++) { myq.offer(a[i]); } for (int i = 0; i < a.length; i++) { a[i] = myq.poll(); } Tidskomplexitet (n = a.length): n gånger offer och n gånger poll ger O(n log n) EDAA30 (Seminarium 13) HT 2015 26 / 38
Effektiv sortering med hjälp av prioritetskö Kommentarer Elementen flyttas från vektorn till en annan intern vektor som representerar kön. Det behövs alltså extra minnesutrymme proportionellt mot storleken på den mängd som ska sorteras. Prioritetskön byggs med successiva offer. Men vi vet att vi kan bygga en prioritetskö effektivare med heapify. Båda punkterna kan förbättras om vi har tillgång till den vektor som representerar kön. Se följande bilder. EDAA30 (Seminarium 13) HT 2015 27 / 38
Sortering på plats i en vektor som representerar en minheap Ex: Gör successiva poll på följande minheap: 10 20 80 20 80 130 150 90 130 150 90 10 80 20 150 90 130 20 80 130 150 90 20 80 130 150 90 10 Efter ett poll Den lediga platsen utnyttjas för att lagra 10. EDAA30 (Seminarium 13) HT 2015 28 / 38
Sortering på plats i en vektor som representerar en minheap Forts Ex: Gör successiva poll på följande minheap: 80 90 130 150 80 90 130 150 10 80 90 130 150 20 10 150 130 90 80 20 10 Nästa poll tar bort 20. Det borttagna elementet 20 placeras på den lediga platsen. Etc... Slutligen har vi en vektor sorterad i omvänd ordning. EDAA30 (Seminarium 13) HT 2015 29 / 38
Heapsort Man kan få vektorn sorterad i växande ordning om man i stället bygger en max-heap, dvs en heap där förälderns nyckel barnens nycklar. Man tar sedan successivt ut största elementet. Ex: sortera en vektorn {10 80 20 130 150 90} Se följande bilder. EDAA30 (Seminarium 13) HT 2015 30 / 38
Heapsort Vi börjar med att utföra heapify på vektorn men nu så att föräldrar blir större än barn. 10 10 80 20 80 90 130 150 90 130 150 20 10 150 150 150 90 10 90 130 90 130 80 20 130 80 20 10 80 20 EDAA30 (Seminarium 13) HT 2015 31 / 38
Heapsort Den resulterande heapen är alltså: 130 150 90 Tag ut största talet (första platsen). Flytta sista noden (20) till luckan som då uppstår på plats 0. Flytta samtidigt den borttagna noden (150) till vektorns sista plats. Blir alltså byte mellan första och sista: 10 80 20 150 130 90 10 80 20 20 130 90 10 80 150 EDAA30 (Seminarium 13) HT 2015 32 / 38
Heapsort De n-1 första elementen i vektorn representerar trädet: 20 Återställ heapordningen i trädet genom percolate-down (blir två byten): 130 130 90 20 90 10 80 10 80 20 130 90 10 80 150 130 80 90 10 20 130 80 90 10 20 150 EDAA30 (Seminarium 13) HT 2015 33 / 38
Heapsort Tag bort det största elementet och byt med elementet på plats n-2: Återställ heapordningen i trädet genom percolate-down (blir ett byte): 20 80 90 10 130 150 90 80 20 Nu är två element på rätt plats. De n-2 första representerar trädet: 10 20 90 80 20 10 130 150 80 90 10 Etc... EDAA30 (Seminarium 13) HT 2015 34 / 38
Heapsort - sammanfattning Sorterar n element i en vektor på plats. Effektiv O(n log n) i värsta fall. Efter k steg i algoritmen är de k största elementen sorterade. Metoden kan alltså avbrytas om vi endast vill ta reda på de k största elementen. Vi kommer att behandla fler effektiva sorteringsalgoritmer senare i kursen. EDAA30 (Seminarium 13) HT 2015 35 / 38
Alternativ representation av prioritetsköer Balanserade binära sökträd är ett tänkbart alternativ: Fungerar dock bara om prioriteterna är unika. Minsta elementet finns längst ner till vänster. Alla operationerna blir O(log n). Om prioriteterna är heltal i ett känt begränsat intervall, t.ex. 1..k: Använd en vektor med listor. Vektorstorlek k + 1. Lägg element med prioriteten j i den lista som finns på plats j i vektorn. Operationerna får konstant tidskomplexitet (k är en konstant). Men ingen generell lösning. EDAA30 (Seminarium 13) HT 2015 36 / 38
Alternativ representation av prioritetsköer Många algoritmer som använder prioritetsköer som hjälpmedel behöver fler operationer: decreasekey(...), increasekey(...) höj/sänk prioriteten på ett element som befinner sig i kön. Det går att använda en heap, men elementen som sätts in måste innehålla information om på vilken plats de befinner sig i vektorn så att de kan flyttas från denna till rätt plats med hänsyn till ordningen. (Utan information om elementets plats skulle man behöva söka igenom vektorn efter elementet). I ett av alternativen för inlämningsuppgiften implementeras en sådan prioritetskö. EDAA30 (Seminarium 13) HT 2015 37 / 38
Alternativ representation av prioritetsköer Om man behöver slå ihop prioritetsköer kan Fibonacciheap användas: Kön representeras här av en mängd (skog av) träd. Kan utföra alla operationer inklusive decreasekey, delete och merge effektivt. Kallas Fibonacciheap eftersom Fibonaccitalen används vid analys av tidskomplexiteten. EDAA30 (Seminarium 13) HT 2015 38 / 38