TDDC30 Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 9 Jonas Lindgren, Institutionen för Datavetenskap, LiU På denna föreläsning: Prioritetskö Heap Representation som länkat träd, array Heapsort 1
Innan vi börjar: Glöm inte att anmäla er till tentan via studentportalen! Det finns två tentapass, det spelar ingen roll vilket man anmäler sig till. Men man får bara gå upp på ett av dem i denna tentaperiod. Träd-quiz! https://www.mentimeter.com/s/7f6d7f3331dd70c41c2fa46d243a4026/0c0de7a350ba 2
Problemet? Scenario 1: I ett musikspelarprogram kan användaren lägga till låtar i en spellista. Programmet spelar sedan upp låtarna i prioritetsordning. Prioriteten bygger på betyg, hur ofta en låt har spelats, och hur länge sedan den senast spelades upp. Scenario 2: Ett flygbolag har ett fullbokat plan. Fler kunder vill följa med så de ställer sig på en standby-kö. Vilka som får ta ev. avbokade platser beror betalad summa, frequent flyer poäng, etc.. 3
ADT Prioritetskö Definition En prioritetskö är en samling nyckel-värde par med två fundamentala metoder: insert(prioritet, värde) värde removemin() Associerar ett värde med en nyckel Tar bort och returnerar elementet med högst prioritet Nyckeln kan vara vilken typ som helst: tal, bokstäver, datum... Nyckeln anger värdets prioritet. (mindre värde på prioritet => högre prioritet) 4
ADT Prioritetskö variant 1 Gränssnittet för ADT prioritetskö: insert(nyckel, värde) värde removemin() värde min() int size() boolean isempty() Associerar ett värde med en nyckel Tar bort och returnerar elementet med högst prioritet Returnerar elementet med högst prioritet Returnerar antalet element i kön Testar om kön är tom Stoppas in i godtycklig ordning Tas ut i sorterad ordning 5
ADT Prioritetskö - variant 2 (PriorityQueue i Java) Prioritetskön tar bara värdena vid insättning. Prioriteten tar man reda på genom att jämföra värdena med varandra: A) Man skickar med en komparator (ett jämföringsobjekt ) när man anropar P-köns konstruktor. B) Man låter värdena vara jämförbara genom att låta klassen implementera interfacet Comparable. PriorityQueue<Song> pq = new PriorityQueue<Song>( new SongComparator() ); PriorityQueue<Song> pq = new PriorityQueue<Song>(); class Song implements Comparable { } 6
Jämförbara objekt För att vi ska kunna använda objekt som nycklar: Måste de implementera interfacet Comparable: public class Song implements Comparable<Song> { int compareto(song right) { } } P-kön anropar compareto på sina element. D.v.s vår compareto-metod, via polymorfi! Eller ha en motsvarande Comparator: public class SongComparator implements Comparator<Song> { int compare(song left, Song right) { } boolean equals(song left, Song right) { } } 7
Sortering Det går att sortera med hjälp av en prioritetskö! PriorityQueue<Song> pq = new PriorityQueue<Song>(); // eller pq = new PriorityQueue<Song>(new SongComparator()); for (Song i : unsortedlist) { pq.add(i); } while (!pq.isempty()) { sortedlist.add(pq.removemin()); } 8
Implementation Implementation som en osorterad lista.. Blir som selection sort när vi väljer! H (6, A ) (4, X ) (8, E ) (2, Y ) / Implementation som en sorterad lista.. Blir som insertion sort när vi stoppar in! H (2, Y ) (4, X ) (6, A ) (8, E ) / Komplexitet? Metod Osorterad lista Sorterad lista size, isempty O(1) O(1) insert O(1) O(n) min, removemin O(n) O(1) 9
Implementation (2) Metod Osorterad lista Sorterad lista Alltså: size, isempty O(1) O(1) insert O(1) O(n) min, removemin O(n) O(1) om det är många insättningsoperationer jmf med remove => välj osorterad lista som implementation. om det är många remove-operationer jmf med insert (?) => välj sorterad lista som implementation. Om min algoritm gör ungefär lika många remove som insert, blir det ju ändå O(n) Kan man inte få så att båda operationerna går halvsnabbt? Självklart! 10
Heap En heap är ett fullständigt binärt träd höjd = log(n) Inte ett binärt sökträd, men.. För varje nod har dess förälder lika eller mindre nyckel Kallas även för min-heap. (Tvärt om blir max-heap). Den minsta nyckeln finns alltid i roten 2 3 8 7 5 9 11
Insättning i Heap 1. Lägg in den nya noden sist i heapen 2. Låt noden bubbla uppåt tills totalordningen återställts 2 1 3 8 3 2 7 5 9 1 7 5 9 8 12
Borttagning ur heap 1. Ta bort rotnoden och ersätt den med noden i slutet av trädet 2. Låt den nya roten bubbla nedåt i trädet tills totalordningen återställts Bubbla alltid med rotens minsta barn 2 9 3 3 8 3 8 5 8 7 5 9 7 5 7 9 13
Arrayrepresentation En heap representeras med fördel med ett fält Kompakt! ADT Representation 2 2 3 8 7 5 9 3 8 7 5 9 Index för root 0 Index för vänster barn Index för höger barn Index för förälder 2*i+1 2*i+2 (i-1)/2 (avrunda nedåt) 14
Komplexitet Operation size, isempty min insert removemin Tid O(1) O(1) O(log(n)) O(log(n)) Att skapa en heap med n element med hjälp av insert tar O(nlog(n)) tid Det finns bättre sätt! 15
Skapa en heap Algoritm för att heapordna en godtycklig array: 1. Börja med att se löven som separata heapar innehållandes en nod var 2. Koppla successivt ihop löven, via sina föräldrar. Bubbla vid behov ned föräldranoden till korrekt plats 3. Upprepa för varje nivå, nedifrån och upp Komplexitet... Räkna antalet bubblingar i värstafallet T(n) = n/2 + n/4 + n/8 +... <= n O(n) 16
Heapsort Algoritm 1. Skapa en heap (O(n)) Måste sorteras i omvänd ordning! 2. Utför removemin för varje element och spara i ett fält O(nlog(n)) Spegelvänder heapens ordning Kan utföras in-place! Fältet konverteras till en heap Elementen plockas bort ur heapen och stoppas in i fältet, från höger till vänster Komplexitet: O(n) + O(nlog(n)) = O(nlog(n)) 17