Föreläsning 1 Innehåll ADT Prioritetskö Prioritetsköer och heapar Prioritetsköer och heapar ADT prioritetskö Klassen PriorityQueue i java.util ar Implementering av prioritetskö med heap Sortering med hjälp av heap Ienprioritetsköskafinnasoperationerföratt sätta in element. ta reda på det högst prioriterade elementet (minsta). ta bort det högst prioriterade elementet (minsta). Elementen innehåller ett eller flera attribut som modellerar elementets prioritet. Jämförelser baseras på prioriteten. Dubbletter är tillåtna. Dvs. många element kan ha samma prioritet. Datavetenskap (LTH) Föreläsning 1 HT 1 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Prioritetskö Exempel på användning Prioritetskö vs FIFO-kö Väntande patienter på en akutmottagning Patienterna beskrivs av en klass som innehåller ett heltalsattribut som anger prioritet. Lågt nummer = hög prioritet. Processer som köar för att få tillgång till CPU i dator. Olika algoritmer finns, t ex: högsta prioritet kortaste jobb kortast återstående tid (First-come-first-served använd vanlig kö istället för prioritetskö) Prioritetskö det viktigaste först Borttagning avser alltid mest prioriterade (minsta) elementet. FIFO-kö bevarar tidsordning First In First Out Borttagning avser alltid äldsta elementet. Sortering heapsort Prioritetsköer används också som hjälpmedel i vissa algoritmer, t ex: grafalgoritmer (Dijkstras algoritm kortaste väg m.m.) ingår i en följande kurs Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 4 / 4
Klassen PriorityQueue i java.util Klassen PriorityQueue i java.util forts. Interfacet Queue<E> används både för prioritetsköer och vanliga FIFO-köer. 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. Det finns flera konstruktorer, bl. a: 1 PriorityQueue() Förutsätter att elementen implementerar Comparable, annars genereras ClassCastException. Inuti PriorityQueue jämförs elementen med compareto. PriorityQueue(Comparator<? super E> c) Elementen jämförs med hjälp av komparatorn c. Observera att en iterering genom prioritetskön inte ger elementen i prioritetsordning. Upprepade borttagningar (poll) gerelementeniprioritetsordning. Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Diskutera Prioritetskö - implementering Lista? Ge några förslag på hur man kan implementera en prioritetskö. Lista Sorterad peek och poll blir O(1) offer blir O(n) rätt plats för elementet måste letas upp Osorterad peek och poll blir O(n) minstaelementmåsteletasupp offer blir O(1) elementet kan sättas in först Nackdel: Vissa operationer blir långsamma. Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 8 / 4
Prioritetskö - implementering forts. Definition 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. 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 Vanligtvis använder man en heap för att implementera prioritetskön. För varje delträd gäller att roten innehåller det minsta elementet. Datavetenskap (LTH) Föreläsning 1 HT 1 9 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Exempel och motexempel 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 i + 1ochi + i vektorn. Noden på plats i har alltså sin förälder på plats (i 1)/. Ingen heap. Fel form, men korrekt ordning Ingen heap. Rätt form men ej korrekt ordning 0 1 4 Datavetenskap (LTH) Föreläsning 1 HT 1 11 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 1 / 4
Implementering av PriorityQueue offer Implementering public class PriorityQueue<E> implements Queue<E> { private E[] queue; private int size;... konstruktorer... boolean offer(e x) {... E peek() {... E poll() {...... 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: Datavetenskap (LTH) Föreläsning 1 HT 1 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 14 / 4 offer Implementering, forts offer Tidskomplexitet Byt! 1 Klart! 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. 1 Byt! 1 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. 1 1 1 Imedeltalblirdetintesåmångabyten.Manharvisatattdetblir O(1) byten i medelfall. Datavetenskap (LTH) Föreläsning 1 HT 1 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 1 / 4
peek Implementering poll Implementering peek: Minsta element finns på plats 0 i vektorn! Blir O(1)-operation. 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 4 1 4 Datavetenskap (LTH) Föreläsning 1 HT 1 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 18 / 4 poll Implementering, forts poll Tidskomplexitet Byt med minsta av barnen! Byt med minsta av barnen! Klart! Ivärstafallfårjämförelsemedbarnenochbytenupprepasändanertill ett löv. Värstafallskostnad för poll blir således O(log n). 4 4 4 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. 4 4 4 Medelfallet kan också visas vara O(log n). Datavetenskap (LTH) Föreläsning 1 HT 1 19 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 / 4
Diskutera Är en heap stabil? Bygga heap från osorterad samling Ibland vill man kunna bygga en prioritetskö av en samling n osorterade element. 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? 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) Tidskomplexitet: A(n) =O(n) och W (n) =O(n log n) Det går att göra effektivare om man kan arbeta direkt med den vektor (heap) som representerar prioritetskön. Datavetenskap (LTH) Föreläsning 1 HT 1 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Bygga heap från osorterad samling Ny konstruktor i klassen PriorityQueue Bygga heap från osorterad vektor ify (eller buildheap) 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 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: 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/,...,0. 10 10 10 10 Börja alltså med percolate down på detta delträd! Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 4 / 4
Bygga heap från osorterad vektor ify (eller buildheap), forts Fortsätt med percolate down här: 10 10 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. ify - 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. 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. 10 10 10 10 10 10 Man kan visa att heapify kostar O(n) där n är antalet element i vektorn. Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 ify - tidskomplexitet Forts ify - implementering Koden för heapify blir enkel: 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. 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.) Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 8 / 4
Diskutera Effektiv sortering med hjälp av prioritetskö Sorteringsidé, för att sortera en vektor a: Man kan använda en prioritetskö för att sortera. Hur? Fördelar/nackdelar? 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) Datavetenskap (LTH) Föreläsning 1 HT 1 9 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 0 / 4 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. 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. 10 10 10 10 Båda punkterna kan förbättras om vi har tillgång till den vektor som representerar kön. Se följande bilder. 10 10 10 10 10 10 Efter ett poll Den lediga platsen utnyttjas för att lagra. Datavetenskap (LTH) Föreläsning 1 HT 1 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 / 4
Sortering på plats i en vektor som representerar en minheap Forts sort 10 10 10 10 Nästa poll tar bort. Det borttagna elementet placeras på den lediga platsen. 10 10 10 10 Etc... Slutligen har vi en vektor sorterad i omvänd ordning. 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 10 Se följande bilder. Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 4 / 4 sort sort Vi börjar med att utföra heapify på vektorn men nu så att föräldrar blir större än barn. 10 10 10 10 Den resulterande heapen är alltså: 10 10 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: 10 10 10 10 10 10 10 10 10 10 Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 / 4
sort sort De n-1 första elementen i vektorn representerar trädet: 10 Återställ heapordningen i trädet genom percolate-down (blir två byten): 10 Tag bort det största elementet och byt med elementet på plats n-: 10 10 Återställ heapordningen i trädet genom percolate-down (blir ett byte): 10 10 10 Nu är två element på rätt plats. De n- första representerar trädet: 10 10 10 10 Etc... Datavetenskap (LTH) Föreläsning 1 HT 1 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 8 / 4 sort - sammanfattning Diskutera 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. 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? Datavetenskap (LTH) Föreläsning 1 HT 1 9 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 40 / 4
Alternativ representation av prioritetsköer Specialfall Alternativ representation av prioritetsköer 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. 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). Datavetenskap (LTH) Föreläsning 1 HT 1 41 / 4 Datavetenskap (LTH) Föreläsning 1 HT 1 4 / 4 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 sort och dess värstafallstid. Datavetenskap (LTH) Föreläsning 1 HT 1 4 / 4