Il tipo astratto Coda con Priorità. Algoritmi e Laboratorio a.a Lezioni. Il tipo astratto Coda con Priorità

Transcript

1 Il tipo astratto Coda con Priorità Università di Torino Facoltà di Scienze MFN Corso di Studi in Informatica Curriculum SR (Sistemi e Reti) Algoritmi e Laboratorio a.a Lezioni prof. Elio Giovannetti Parte 20 Code con priorità versione 0/0/200 Quest' opera è pubblicata sotto una Licenza Creative Commons Attribution-NonCommercial-ShareAlike 2.5. Una coda con priorità è una collezione di elementi ognuno dei quali possiede una certa priorità (rappresentata ad es. da un numero naturale). Esempio: un insieme di richieste di lavori, di cui alcuni più urgenti di altri. Una coda con priorità, a differenza di una coda ordinaria, non obbedisce ad una disciplina FIFO, poiché da essa si estrae ogni volta quello (o uno di quelli) con priorità più alta. È consuetudine che la priorità più alta possibile sia indicata dal numero, e le priorità inferiori da numeri interi più grandi. L'operazione di estrazione dalla coda è allora un'operazione di estrazione del minimo. 0/0/200. E. Giovannetti - AlgELab Lez.20 2 Il tipo astratto Coda con Priorità Le operazioni fondamentali che definiscono il tipo astratto Coda con Priorità sono allora: inserimento di un elemento con una data priorità; estrazione dell'elemento con il valore minimo di priorità; restituzione di tale minimo senza estrarlo dalla coda; test se la coda è vuota o no. Come nel caso del dizionario, si possono dare definizioni diverse a seconda che la coda si consideri costituita di coppie elemento, priorità oppure che si consideri ogni elemento come "contenente al proprio interno" la priorità. Si possono poi definire altre operazioni, come: variazione della priorità di un elemento della coda; cancellazione di un elemento della coda; fusione di due code con priorità; Esempio di definizione (da Demetrescu) 0/0/200. E. Giovannetti - AlgELab Lez.20 0/0/200. E. Giovannetti - AlgELab Lez.20 4 Esempio di definizione (continua) Nota: la chiave non è nient'altro che la priorità. Possibili realizzazioni liste ordinate (in ordine crescente): l'elemento di priorità più alta, cioè il minimo, è il primo, ma l'inserimento è un inserimento al posto giusto in lista ordinata; quindi: estrazione del minimo: complessità Θ(); inserimento (casi medio e peggiore): complessità Θ(n); liste non ordinate: l'inserimento può avvenire sempre in testa, ma l'estrazione è una ricerca del minimo in sequenza non ordinata, quindi: estrazione del minimo: complessità Θ(n); inserimento: complessità Θ(); rappresentare la sequenza come un array non migliora la situazione (se è ordinato, l'inserimento è Θ(n); se non è ordinato, è Θ(n) l'estrazione ) 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez.20 6

2 Coda con priorità "a massimo". Non cambia nulla se si assume che la priorità più alta sia quella di valore massimo: basta sostituire l'ordine crescente con l'ordine decrescente, ed il minimo con il massimo. Un'idea migliore: albero parzialmente ordinato Un albero (binario) in cui la chiave di ciascun nodo è minore o uguale delle chiavi dei figli. Nota Bene: NON è un albero di ricerca (l'ordinamento è, per così dire, dall'alto in basso e non da sinistra a destra). Quindi: il minimo è l'elemento nella radice; ogni cammino dalla radice a una foglia è ordinato; Allora: per inserire un elemento basterebbe percorrere un qualsiasi cammino inserendo l'elemento al posto giusto; per estrarre il minimo basterebbe estrarre la radice e ricorsivamente far salire come radice il minore dei figli; in entrambi i casi, se l'albero è bilanciato, la lunghezza del cammino da percorrere è Θ(log n). 0/0/200. E. Giovannetti - AlgELab Lez.20 0/0/200. E. Giovannetti - AlgELab Lez.20 8 Esempio Su ogni cammino dalla radice a una foglia la sequenza delle chiavi è una sequenza ordinata. Esempio (continua) se estraiamo il minimo, cioè la radice, facciamo salire al suo posto il minore dei figli: per definizione, esso risulterà minore (o uguale) di tutti i nodi dell'albero /0/200. E. Giovannetti - AlgELab Lez.20 0/0/200. E. Giovannetti - AlgELab Lez.20 0 Esempio (continua) il nodo lasciato libero viene occupato facendo a sua volta salire il minore dei figli e così via Esempio (continua) /0/200. E. Giovannetti - AlgELab Lez.20 0/0/200. E. Giovannetti - AlgELab Lez

3 Esempio (continua) Secondo esempio fino a far salire una foglia /0/200. E. Giovannetti - AlgELab Lez.20 0/0/200. E. Giovannetti - AlgELab Lez.20 4 Secondo esempio (continua) se estraiamo il minimo, cioè la radice, facciamo salire al suo posto il minore dei figli: per definizione, esso risulterà minore (o uguale) di tutti i nodi dell'albero Secondo esempio (continua) il nodo lasciato libero viene occupato facendo a sua volta salire il minore dei figli /0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez.20 6 Secondo esempio (fine) La foglia cancellata non è all'ultimo livello Problema: come mantenere il bilanciamento Una successione di inserimenti ed estrazioni può produrre un albero molto sbilanciato, per il quale l'altezza non è più logaritmica rispetto al numero dei nodi. Per mantenere il bilanciamento si può fare in modo che l'albero rimanga sempre quasi completo, cioè completo almeno fino al penultimo livello. A tal fine, è sufficiente fare in modo che l'inserimento e l'estrazione modifichino la forma dell'albero soltanto per l'aggiunta o l'eliminazione di un nodo all'ultimo livello (intendendo per ultimo livello quello "reale", cioè non contando il livello dei nodi nulli) /0/200. E. Giovannetti - AlgELab Lez.20 0/0/200. E. Giovannetti - AlgELab Lez.20 8

4 Come mantenere il bilanciamento: soluzione. Inserimento: esempio. L'albero viene mantenuto quasi completo, nel modo seguente: inserimento: il nuovo elemento viene inserito come foglia all'ultimo livello e poi fatto risalire al posto giusto mediante scambi col genitore; estrazione del minimo: il minimo è la radice, che si estrae; ma al suo posto, invece di far salire il figlio minore, si sposta una foglia dell'ultimo livello, che viene poi fatta scendere al posto giusto scambiandola ogni volta col minore dei figli Vogliamo inserire l'elemento 2. 0/0/200. E. Giovannetti - AlgELab Lez.20 0/0/200. E. Giovannetti - AlgELab Lez Inserimento: esempio (continua). Inserimento: esempio (continua) Inseriamo l'elemento 2 come foglia all'ultimo livello; è minore del genitore, scambiamolo con esso. 0/0/200. E. Giovannetti - AlgELab Lez.20 2 È di nuovo minore del genitore e quindi anche del fratello: scambiamolo con il genitore. 0/0/200. E. Giovannetti - AlgELab Lez Inserimento: esempio (continua). Estrazione del minimo: esempio È maggiore del genitore: quindi è al posto giusto, l'albero è di nuovo parzialmente ordinato. 0/0/200. E. Giovannetti - AlgELab Lez.20 2 Restituiamo il valore della radice, cioè ; 0/0/200. E. Giovannetti - AlgELab Lez

5 Estrazione del minimo: esempio (continua). Estrazione del minimo: esempio (continua) poi spostiamo nella radice una foglia dell'ultimo livello; 0/0/200. E. Giovannetti - AlgELab Lez il nodo-radice non è minore (o uguale) di ognuno dei figli, anzi è maggiore di entrambi; per ripristinare la proprietà violata, lo dobbiamo scambiare con il minore dei figli; 0/0/200. E. Giovannetti - AlgELab Lez Estrazione del minimo: esempio (continua). Estrazione del minimo: esempio (continua) di nuovo il nodo rosso non è minore di ognuno dei figli; per ripristinare la proprietà, lo dobbiamo scambiare con il minore dei figli; 0/0/200. E. Giovannetti - AlgELab Lez.20 2 Il nodo è minore dei figli (anzi, dell'unico figlio); quindi è al posto giusto, l'albero è di nuovo parzialmente ordinato. 0/0/200. E. Giovannetti - AlgELab Lez Problema: come realizzare gli algoritmi precedenti. Per poter realizzare concretamente con complessità logaritmica i due algoritmi astratti precedenti, bisogna: trovare in tempo costante (o al più logaritmico) quale foglia tagliare oppure creare; essere in grado, nell'algoritmo di inserimento, di risalire dal figlio al padre in tempo costante. Soluzione: la struttura-dati heap. L'albero viene mantenuto quasi-completo da sinistra, cioè binario quasi-completo (vedi slides Lez. 5) con tutte le foglie dell'ultimo livello "addossate a sinistra". Nota terminologica. Un albero d-ario con le proprietà richieste, cioè: la chiave di ciascun nodo è minore o uguale della chiave di ogni suo figlio non nullo; l'albero è quasi-completo da sinistra; viene detto heap (non confondere con lo heap del modello di memoria dei linguaggi di programmazione). L'albero-heap viene realizzato per mezzo di un array in cui i nodi sono memorizzati consecutivamente per livelli. 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez

6 Esempio di heap (binario, a minimo) Albero-heap realizzato come array La forma regolare ne permette la realizzazione tramite array. Conviene, come vedremo, non utilizzare l'elemento di indice 0. Si osservi che ogni sottoalbero di uno heap è a sua volta uno heap. 0/0/200. E. Giovannetti - AlgELab Lez.20 0/0/200. E. Giovannetti - AlgELab Lez.20 2 Proprietà Se i nodi vengono memorizzati nell'array a partire dall'indice (lasciando inutilizzato l'elemento di indice 0), i figli del nodo memorizzato nell'elemento di indice i risultano memorizzati rispettivamente negli elementi di indice 2i e 2i+: left(i) = 2i right(i) = 2i+ quindi: parent(i) = i/2 2 Nota implementativa Come in molte altre situazioni dello stesso genere, in cui un elemento deve venire scambiato più volte con successivi elementi di una sequenza (pensa ad esempio all'insertion sort), conviene tenere tale elemento in un temporaneo e inserirlo solo alla fine nella posizione giusta. È quindi come se ogni volta si scambiasse un elemento con un posto vuoto, il quale alla fine raggiunge la posizione corretta in cui inserire il valore tenuto nel temporaneo /0/200. E. Giovannetti - AlgELab Lez.20 0/0/200. E. Giovannetti - AlgELab Lez.20 4 Una realizzazione elementare in Java Assumiamo, per semplicità, che gli elementi della coda siano degl'interi coincidenti con le loro priorità. Nell'array degli elementi lasciamo inutilizzato il posto di indice 0. Inserimento Si aggiunge un nodo posto-vuoto alla fine dell'albero, cioè al fondo dell'array: lastindex++; public class PriorityQueue { private int[] elements; private int lastindex; public PriorityQueue(int n) { this.elements = new int[n+]; lastindex = 0; // crea una coda vuota 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez

7 Inserimento (continua) Inserimento (continua) Se l'elemento da inserire è minore del genitore del posto vuoto, si sposta il genitore nel posto vuoto, facendo virtualmente salire il posto vuoto. 0/0/200. E. Giovannetti - AlgELab Lez.20 Se l'elemento da inserire è ancora minore del genitore del posto vuoto si ripete il procedimento, e così via finché il posto vuoto non risale nella posizione giusta. 0/0/200. E. Giovannetti - AlgELab Lez.20 8 Inserimento (continua) Inserimento (fine) All'uscita dal while, o il posto vuoto è la radice, oppure il genitore del posto vuoto è minore (o uguale) dell'elemento da inserire; perciò si inserisce l'elemento nel posto vuoto: elements[i] = newelement; int i = lastindex; while(i > && newelement < elements[i/2]){ elements[i] = elements[i/2]; // sposta in giù il genitore i = i/2; // sposta in su il posto vuoto 0/0/200. E. Giovannetti - AlgELab Lez.20 0/0/200. E. Giovannetti - AlgELab Lez Si estrae la radice: int min = elements[]; Estrazione del minimo Estrazione del minimo (continua) Si toglie l'ultimo nodo, e lo si mette al posto della radice: int last = elements[lastindex]; lastindex--; if(lastindex > 0) { // coda non vuota elements[] = last; 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez.20 42

8 Estrazione del minimo (continua) La procedura movedown o fixheap La procedura movedown (o una sua analoga) è da molti chiamata fixheap o, in italiano, aggiustaheap (nell'inglese americano to fix vuol dire aggiustare, riparare). Dato uno heap o un sottoheap in cui solo la radice è eventualmente "fuori posto", cioè maggiore di almeno uno dei figli, la fa scendere al posto giusto, scambiandola ogni volta con il minore dei figli. In tal modo essa "ripara" lo heap o sottoheap considerato, ripristinandone la proprietà caratteristica degli heap. La radice sarà in generale fuori posto, perché maggiore di uno dei suoi figli (o di entrambi); allora la si fa scendere al posto giusto per mezzo di una procedura movedown. 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez Procedura movedown o fixheap Si scambia il nodo fuori posto con il suo figlio minore, finché il nodo si trova ad essere non maggiore dei figli, oppure a non avere figli (cioè è diventato una foglia). Procedura movedown o fixheap 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez Definiamo i due metodi privati ausiliari moveup e movedown i quali, dato un solo elemento "fuori posto" nello heap, lo fanno rispettivamente salire o scendere a un posto giusto: private void moveup(int i): se i è l'indice di un elemento eventualmente "fuori posto rispetto al genitore", lo fa risalire al posto giusto; private void movedown(int i): se i è l'indice di un elemento eventualmente "fuori posto rispetto ai figli", lo fa scendere al posto giusto. I metodi di inserimento, estrazione del minimo, variazione di priorità sono poi realizzati per mezzo dell'uno o dell'altro dei due metodi precedenti. public void moveup(int i) { if(i > lastindex) throw new IllegalArgumentException(); int elem = elements[i]; // elemento da far salire while(i > && elem < elements[i/2]) { // minore del padre elements[i] = elements[i/2]; // sposta in giù il padre i = i/2; // sposta in su il posto per l'elemento elements[i] = elem; public void add(int newelement) { if(lastindex == elements.length-) rialloca(); // mette il nuovo elemento in una nuova foglia: elements[++lastindex] = newelement; moveup(lastindex); // lo fa risalire al posto giusto 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez

9 Attenzione Non confondere il tipo int dell'argomento i di moveup, che è un indice di array, con il tipo dell'argomento newelement di add, che in questa versione semplificata è anch'esso un int, ma che è il tipo degli elementi della coda e può quindi in generale essere un tipo qualunque su cui sia definita una relazione d'ordine (ossia un metodo compare). Analogamente il tipo int dell'argomento i di movedown è un indice di array, da non confondersi con il tipo int del minimo che viene estratto, che è ovviamente anch'esso il tipo degli elementi della coda. public void movedown(int i) { if(i > lastindex) throw new IllegalArgumentException(); int elem = elements[i]; // nodo da far scendere ciclo con due punti di uscita: all'inizio: si esce se il nodo è una foglia alla fine: si esce se l'elemento è minore dei due figli (o dell'unico figlio) while(2*i <= lastindex) { // while il nodo ha almeno un figlio int ichild = 2*i; // indice del figlio sinistro int child = elements[ichild]; child è il figlio sinistro int j = ichild + ; // indice del figlio destro if(j <= lastindex && elements[j] < child) { // se il figlio destro esiste ed è il minore, child è il figlio destro ichild = j; (nota che j è ichild+, quindi si sarebbe potuto scrivere ichild++) child = elements[j]; a questo punto child è il minore dei figli, ichild è il suo indice (continua nella slide seguente) 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez Se l'elemento è maggiore del figlio minore, scambiamo il figlio con il posto vuoto: if(elem > child ) { elements[i] = child ; // facciamo salire il figlio i = ichild ; // facciamo scendere il posto vuoto else break; se l'elemento non è maggiore di nessun figlio, è al posto giusto. all'uscita dal while la posizione i o non ha figli oppure ha figli entrambi maggiori o uguali del nodo da mettere a posto; quindi i è il posto giusto: elements[i] = elem; Osservazione: La forma del ciclo con due uscite, di cui una realizzata con il break, è quella che aderisce meglio alla logica del programma. Una volta l'uso dei break, cioè dei cicli a uscite multiple, era sempre considerato sconveniente, e per evitarlo ci si costringeva a introdurre artificiose variabili booleane. 0/0/200. E. Giovannetti - AlgELab Lez.20 5 L'intera procedura public void movedown(int i) { if(i > lastindex) throw new IllegalArgumentException(); int elem = elements[i]; // nodo da far scendere while(2*i <= lastindex) { // while il nodo ha almeno un figlio int ichild = 2*i; // indice del figlio sinistro int child = elements[ichild]; child è il figlio sinistro int j = 2*i + ; // indice del figlio destro if(j <= lastindex && elements[j] < child) { ichild = j; // se il figlio destro esiste ed è il minore child = elements[j]; // child è il figlio destro if(elem > child ) { elements[i] = child ; // facciamo salire il figlio i = ichild ; // facciamo scendere il posto vuoto else break; se l'elemento non è maggiore di nessun figlio, elements[i] = elem; 0/0/200. E. Giovannetti - AlgELab Lez Estrazione del minimo: public int removemin() { if(lastindex == 0) throw new Illegal (); int minimum = elements[]; if movedown(); return minimum; Un eventuale metodo che incrementa o decrementa di un intervallo delta la priorità dell'elemento di indice i: public void changepriority(int i, int delta) { if(i > lastindex) throw new Illegal; elements[i] += delta; if(delta > 0) movedown(i); else if(delta < 0) moveup(i); Un tale metodo sembra poco sensato, poiché in generale non si sa qual è l'elemento di indice i nella coda. Esso (o una sua variante) è invece utilizzato in un algoritmo sui grafi. 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez.20 54

10 Analisi della complessità Le due procedure moveup e movedown sono entrambe nel caso peggiore logaritmiche nel numero degli elementi, poiché percorrono un ramo di un albero binario quasi completo impiegando un tempo costante per ogni passo. Tali sino quindi anche tutte le operazioni considerate, in particolare l'estrazione del minimo e l'inserimento. Per esse si ha dunque: T worst (n) = Θ(log n) Riassunto Procedure Coda con Priorità (a minimo) void moveup(int i) fa salire al posto giusto l'elemento di indice i: risale il ramo dell'albero dal nodo i verso la radice, spostando in giù di una posizione ogni nodo (padre) finché arriva ad un elemento minore (cioè di priorità più alta) di quello da mettere a posto, oppure alla radice; inserisce nel "posto libero" l'elemento. void movedown(int i) fa scendere al posto giusto l'elemento di indice i: percorre un ramo dell'albero dal nodo i verso il basso, scegliendo ogni volta il minore dei figli e spostandolo nel padre, finché arriva ad un elemento maggiore (cioè di priorità più bassa) di quello da mettere a posto, oppure ad una foglia; inserisce nel "posto libero" l'elemento. 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez Riassunto Procedure Coda con Priorità (a minimo) void add(e el) inserisce in coda l'elemento el: inserisce el in una nuova foglia al fondo dell'albero, e poi la fa risalire al posto giusto. E removemin() estrae dalla coda il minimo: estrae la radice, sposta l'ultima foglia nella radice e poi la fa scendere al posto giusto. Aspetti realizzativi (parte opzionale) void changeprority(int i, int delta) cambia la priorità dell'elemento di indice i: a seconda del segno di delta, fa salire oppure scendere l'elemento. 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez Alcune possibili versioni più generali.. Coda di elementi di tipo parametrico E, con il vincolo che su E sia definita una relazione d'ordine totale, cioè: in Java: public class PriorityQueue<E extends Comparable<E>> in C#: public class PriorityQueue<E> where E: IComparable<E> in cui quindi la priorità non è necessariamente un intero. 2. Coda di coppie elemento, priorità, dove l'elemento è di un tipo parametrico E qualsiasi, senza vincoli, mentre la priorità è un intero.... 0/0/200. E. Giovannetti - AlgELab Lez.20 5 Versione : realizzazione in C# con array generico. using System; public class PriorityQueue<E> where E: IComparable<E> { private E[] elements; private int lastindex; // indice dell'ultimo // elemento presente public PriorityQueue(int n) { this.elements = new E[n]; lastindex = 0; // lasciamo vuoto l'el. di indice 0 public bool isempty() { return lastindex == 0; 0/0/200. E. Giovannetti - AlgELab Lez

11 Versione : realizzazione in Java con una ArrayList. In Java, per evitare i problemi degli array generici, possiamo usare una ArrayList: public class PriorityQueue<E extends Comparable<E>> { private ArrayList<E> elements; public PriorityQueue() { elements = new ArrayList<E>(); elements.add(null); // lasciamo vuoto l'elemento di indice 0 Versione 2: realizzazione in C# public class PriorityQueue<E> { struct ElementWithPriority{ public E element; public int priority; public ElementWithPriority(E e, int p) { element = e; priority = p; private ElementWithPriority[] elements; private int lastindex; public PriorityQueue(int n) { this.elements = new ElementWithPriority[n+]; lastindex = 0; 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez Versione 2: realizzazione in C# (continua) public void moveup(int i) { if(i > lastindex) throw new ArgumentException(); ElementWithPriority elem = elements[i]; while(i> && elem.priority < elements[i/2].priority) { elements[i] = element; public void add(int prior, E newelem) { if(lastindex == elements.length-) rialloca(); lastindex++; int i = lastindex; elements[i] = new ElementWithPriority(newElem, prior); moveup(i); Versione 2: realizzazione in C# (continua) Esempio di uso PriorityQueue<String> q = new PriorityQueue<String>(5); q.add(, "Pulisci i tappeti"); q.add(, "Svuota il cestino"); q.add(8, "Innaffia le piante"); q.add(0, "Butta via i trucioli del temperamatite"); q.add(6, "Sostituisci lampadina"); q.add(, "Ripara il lavandino"); q.add(, "Pulisci la caffettiera"); q.add(2, "Acquista materiali per pulizia"); while (!q.isempty()) Console.WriteLine(q.remove()); 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez Esercizi Completare la classe PriorityQueue di tipo generico in C#. Realizzare la classe PriorityQueue di tipo generico in Java utlizzando l'arraylist. Definire una classe che implementi IComparable (in C#) o Comparable (in Java) e realizzare poi una semplice classe con un main di prova della PriorityQueue. Completare la versione "realistica" 2 in C#. Modificare le soluzioni degli esercizi precedenti in modo che diventino degli heap a massimo (invece che a minimo). Realizzare una classe PriorityQueue con heap ternario invece che binario (cioè albero d-ario con d= invece che 2; vedi libro di testo). Domanda Si potrebbe, come per lo heap, memorizzare un albero binario di ricerca in un array, in modo da essere in grado di accedere rapidamente ai figli e al genitore di un nodo di indice i, cioè semplicemente andando agli elementi di indice rispettivamente 2i, 2i+, e i/2? Se si, come e con quali pro e contro? 0/0/200. E. Giovannetti - AlgELab Lez /0/200. E. Giovannetti - AlgELab Lez.20 66