ADT Prioritetskö. Föreläsning 12 Innehåll. Prioritetskö. Interface för Prioritetskö. Prioritetsköer och heapar

Transkript

1 Föreläsning 1 Innehåll Prioritetsköer och heapar Prioritetsköer och heapar ADT prioritetskö Klassen PriorityQueue i java.util Heapar Implementering av prioritetskö med heap Sortering med hjälp av heap Undervisningsmoment: föreläsning 1, övningsuppgifter 1 Avsnitt i läroboken:., 8.8 I :a upplagan:., 8.8 PFK (Föreläsning 1) VT 1 1 / 4 ADT Prioritetskö 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. Dubbletter är tillåtna. Dvs. många element kan ha samma prioritet. Ienprioritetsköskafinnasoperationerföratt sätta in element. ta reda på det högst prioriterade elementet (minsta). ta bort det högst prioriterade elementet (minsta). PFK (Föreläsning 1) VT 1 / 4 Prioritetskö Interface för Prioritetskö FIFO-kö bevarar tidsordning Borttagning avser alltid äldsta elementet. Prioritetskö det viktigaste först Borttagning avser alltid mest prioriterade (minsta) elementet. Exempel: 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 IJavafinnsingetspecielltinterfaceförprioritetskö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. PFK (Föreläsning 1) VT 1 / 4 PFK (Föreläsning 1) VT 1 4 / 4

2 Klassen PriorityQueue i java.util Diskutera Det finns flera konstruktorer, bl. a.: 1 PriorityQueue() PriorityQueue(Comparator<? super E> c) Den första konstruktorn förutsätter att elementen implementerar Comparable, annarsgenererasclasscastexception. Används den andra konstruktorn jämförs elementen med hjälp av komparatorn c. Skillnader/likheter mellan en FIFO-kö och prioritetskö? Vad kan man använda för att implementera en prioritetskö? PFK (Föreläsning 1) VT 1 / 4 PFK (Föreläsning 1) VT 1 / 4 Prioritetskö - implementering Lista? Prioritetskö - implementering, forts. Balanserat binärt sökträd? Lista sorteradellerosorterad 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 Nackdel: Vissa operationer blir långsamma. Balanserat binärt sökträd: Fungerar bara om prioriteterna är unika. Minsta elementet finns längst ner till vänster. Alla operationerna blir O(log n). Nackdel: Klarar inte dubbletter. Heap Vanligtvis använder man en heap för att implementera prioritetskön. PFK (Föreläsning 1) VT 1 / 4 PFK (Föreläsning 1) VT 1 8 / 4

3 Heap Definition Heap Exempel och motexempel Heap En heap är ett komplett binärt träd där varje nod innehåller ett element som är apple barnens element. Trädet har alltså formen För varje delträd gäller att roten innehåller det minsta elementet. Heap Ingen heap. Fel form, men korrekt ordning Ingen heap. Rätt form men ej korrekt ordning PFK (Föreläsning 1) VT 1 9 / 4 PFK (Föreläsning 1) VT 1 / 4 Heap Representation Implementering av PriorityQueue En heap kan med fördel lagras i en vektor. Roten finns på plats 0. Barnen till noden på plats i finns på platserna i + 1ochi + i vektorn. Noden på plats i har alltså sin förälder på plats (i 1)/. public class PriorityQueue<E> implements Queue<E> { private E[] queue; private int size;... konstruktorer boolean offer(e x) {... E peek() {... E poll() { PFK (Föreläsning 1) VT 1 11 / 4 PFK (Föreläsning 1) VT 1 1 / 4

4 offer Implementering offer Implementering, forts 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. Byt! 1 Klart! Ex: Sätt in element med nyckel 1 i heapen: 1 Byt! PFK (Föreläsning 1) VT 1 1 / 4 PFK (Föreläsning 1) VT 1 14 / 4 offer Tidskomplexitet peek Implementering 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. peek: Minsta element finns på plats 0 i vektorn! Blir O(1)-operation. Imedeltalblirdetintesåmångabyten.Manharvisatattdetblir O(1) byten i medelfall. PFK (Föreläsning 1) VT 1 1 / 4 PFK (Föreläsning 1) VT 1 1 / 4

5 poll Implementering poll Implementering, forts 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. Byt med minsta av barnen! Byt med minsta av barnen! Klart! Kallas percolate down eller addroot Ex: Utför poll() på: PFK (Föreläsning 1) VT 1 1 / 4 PFK (Föreläsning 1) VT 1 18 / 4 poll Tidskomplexitet Diskutera Är en heap stabil? Ivärstafallfårjämförelsemedbarnenochbytenupprepasändanertill 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). En prioritetskö är stabil om element med lika prioritet plockas ut i samma ordning som de sattes in. Är en heap stabil? Prova att sätta in tre element med samma prioritet (t.ex. 1) i en heap. I vilken ordning plockas de ut? PFK (Föreläsning 1) VT 1 19 / 4 PFK (Föreläsning 1) VT 1 / 4

6 Bygga heap från osorterad samling Bygga heap från osorterad samling Ny konstruktor i klassen PriorityQueue 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. 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 PFK (Föreläsning 1) VT 1 1 / 4 PFK (Föreläsning 1) VT 1 / 4 Bygga heap från osorterad vektor Heapify (eller buildheap) 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: Bygga heap från osorterad vektor Heapify (eller buildheap), forts Fortsätt med percolate down här: Bygg en heap på plats i vektorn genom att utföra percolate down med början på den nod som finns på plats n/ 1sedanpåplatsn/,..., Börja alltså med percolate down på detta delträd! 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 PFK (Föreläsning 1) VT 1 / 4 PFK (Föreläsning 1) VT 1 4 / 4

7 Heapify - tidskomplexitet Heapify - tidskomplexitet Forts 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. De utför vardera därför maximalt byten etc. Ju högre upp i trädet desto färre noder men desto fler byten nedåt i värsta fall. 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. Man kan visa att heapify kostar O(n) där n är antalet element i vektorn. PFK (Föreläsning 1) VT 1 / 4 PFK (Föreläsning 1) VT 1 / 4 Heapify - implementering Diskutera Koden för heapify blir enkel: private void heapify() { for (int i = (size - ) / ; i >= 0; i--) { percolatedown(i); Sista elementet finns på plats size på plats (size )/. 1 i vektorn ) dess förälder finns 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.) Man kan använda en prioritetskö för att sortera. Hur? Fördelar/nackdelar? PFK (Föreläsning 1) VT 1 / 4 PFK (Föreläsning 1) VT 1 8 / 4

8 Effektiv sortering med hjälp av prioritetskö Effektiv sortering med hjälp av prioritetskö Kommentarer 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) 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. PFK (Föreläsning 1) VT 1 9 / 4 PFK (Föreläsning 1) VT 1 0 / 4 Sortering på plats i en vektor som representerar en minheap Bygg om den osorterade vektorn till en minheap heapify(). Gör sedan successiva poll på minheapen. Sortering på plats i en vektor som representerar en minheap Forts Efter ett poll Den lediga platsen utnyttjas för att lagra. Nästa poll tar bort. Det borttagna elementet placeras på den lediga platsen. Etc... Slutligen har vi en vektor sorterad i omvänd ordning. PFK (Föreläsning 1) VT 1 1 / 4 PFK (Föreläsning 1) VT 1 / 4

9 Heapsort Heapsort Vi börjar med att utföra heapify på vektorn men nu så att föräldrar blir större än barn. 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 { Se följande bilder PFK (Föreläsning 1) VT 1 / 4 PFK (Föreläsning 1) VT 1 4 / 4 Heapsort Heapsort De n-1 första elementen i vektorn representerar trädet: Återställ heapordningen i trädet genom percolate-down (blir två byten): Den resulterande heapen är alltså: Tag ut största talet (första platsen). Flytta sista noden () till luckan som då uppstår på plats 0. Flytta samtidigt den borttagna noden (10) till vektorns sista plats. Blir alltså byte mellan första och sista: PFK (Föreläsning 1) VT 1 / 4 PFK (Föreläsning 1) VT 1 / 4

10 Heapsort Heapsort - sammanfattning Tag bort det största elementet och byt med elementet på plats n-: Nu är två element på rätt plats. De n- första representerar trädet: Återställ heapordningen i trädet genom percolate-down (blir ett byte): Sorterar n element i en vektor på plats. Effektiv O(n log n) ivärstafall. 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. Etc... PFK (Föreläsning 1) VT 1 / 4 PFK (Föreläsning 1) VT 1 8 / 4 Diskutera Alternativ representation av prioritetsköer Specialfall Antag att prioriteterna är heltal i ett känt begränsat intervall 1..k, t ex 1... Finns det något bättre (snabbare, enklare) sätt än heap att implementera en prioritetskö i just detta specialfall? 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 idenlistasomfinnspåplatsj i vektorn. Operationerna får konstant tidskomplexitet (k är en konstant). Men ingen generell lösning. PFK (Föreläsning 1) VT 1 9 / 4 PFK (Föreläsning 1) VT 1 40 / 4

11 Alternativ representation av prioritetsköer Prioritetsköer och heapar Många algoritmer som använder prioritetsköer som hjälpmedel behöver fler operationer: decreasekey(...), increasekey(...) höj/sänkprioritetenpå 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). 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. PFK (Föreläsning 1) VT 1 41 / 4 PFK (Föreläsning 1) VT 1 4 / 4 Datorlaboration Använda en map för att implementera en telefonkatalog. Grafiskt användargränssnitt med menyer för att hantera telefonkatalogen. Innehåll: ADT Map, använda klasser från paketet java.util, JavaFX. PFK (Föreläsning 1) VT 1 4 / 4