aggiunte implementazioni coda prioritaria

src/it/algoritmi/adt/queue/AbstractPriorityQueue.java

@@ -38,7 +38,7 @@ public abstract class AbstractPriorityQueue<K extends Comparable<K>, V> implemen
 	//-------- fine della classe annidata ------------------------
 
 	/** Il comparatore che definisce l'ordine tra le chiavi della coda prioritaria */
-	private Comparator<K> comparator;
+	protected Comparator<K> comparator;
 	
 	/** Crea una coda prioritaria vuota che usa il comparatore fornito. */
 	protected AbstractPriorityQueue(Comparator<K> comparator) {

src/it/algoritmi/adt/queue/SortedPriorityQueue.java

@@ -0,0 +1,59 @@
+package it.algoritmi.adt.queue;
+
+import java.util.Comparator;
+
+import it.algoritmi.adt.Entry;
+import it.algoritmi.adt.Position;
+import it.algoritmi.adt.PositionalList;
+import it.algoritmi.adt.list.LinkedPositionalList;
+
+public class SortedPriorityQueue<K extends Comparable<K>, V> extends AbstractPriorityQueue<K, V> {
+
+	/** Contenitore principale delle voci della coda prioritaria */
+	private PositionalList<Entry<K, V>> list = new LinkedPositionalList<>();
+	
+	/** Crea una coda prioritaria vuota che usa l'ordine naturale tra le chiavi. */
+	public SortedPriorityQueue() {
+		super();
+	}
+	
+	public SortedPriorityQueue(Comparator<K> comparator) {
+		this.comparator = comparator;
+	}
+
+	@Override
+	public int size() {
+		return list.size();
+	}
+	
+
+	@Override
+	public Entry<K, V> insert(K key, V value) throws IllegalArgumentException {
+		checkKey(key); // metodo ausiliario di verifica (può lanciare eccezione)
+		Entry<K, V> newest = new PQEntry<>(key, value);
+		Position<Entry<K, V>> walk = list.last();
+		// procede a ritroso, cercando chiavi minori
+		while (walk != null && compare(newest, walk.getElement()) < 0)
+			walk = list.before(walk);
+		if (walk == null)
+			list.addFirst(newest);
+		else
+			list.addAfter(walk, newest);
+		return newest;
+	}
+	
+
+	@Override
+	public Entry<K, V> min() {
+		if(list.isEmpty()) return null;
+		return list.first().getElement();
+	}
+	
+
+	@Override
+	public Entry<K, V> removeMin() {
+		if(list.isEmpty()) return null;
+		return list.remove(list.first());
+	}
+
+}

src/it/algoritmi/adt/queue/UnsortedPriorityQueue.java

@@ -0,0 +1,64 @@
+package it.algoritmi.adt.queue;
+
+import java.util.Comparator;
+
+import it.algoritmi.adt.Entry;
+import it.algoritmi.adt.Position;
+import it.algoritmi.adt.PositionalList;
+import it.algoritmi.adt.list.LinkedPositionalList;
+
+/** Un'implementazione di coda prioritaria mediante una lista non ordinata. */
+public class UnsortedPriorityQueue<K extends Comparable<K>, V> extends AbstractPriorityQueue<K, V> {
+
+	/** Contenitore principale delle voci della coda prioritaria */
+	private PositionalList<Entry<K, V>> list = new LinkedPositionalList<>();
+	
+	/** Crea una coda prioritaria vuota che usa l'ordine naturale tra le chiavi. */
+	public UnsortedPriorityQueue() {
+		super();
+	}
+	
+	/** Crea una coda prioritaria vuota che usa il comparatore fornito. */
+	public UnsortedPriorityQueue(Comparator<K> comparator) {
+		super(comparator);
+	}
+
+	/** Restituisce la Position di una delle voci aventi chiave minima. */
+	private Position<Entry<K, V>> findMin() {
+		Position<Entry<K, V>> small = list.first();
+		for(Position<Entry<K, V>> walk : list.positions())
+			if(compare(walk.getElement(), small.getElement()) < 0)
+				small = walk;
+		return small;
+	}
+
+	/** Restituisce il numero di voci presenti nella coda prioritaria. */
+	@Override
+	public int size() {
+		return list.size();
+	}
+
+	/** Inserisce una coppia chiave-valore e restituisce la voce creata. */
+	@Override
+	public Entry<K, V> insert(K key, V value) throws IllegalArgumentException {
+		checkKey(key); // metodo ausiliario di verifica (può lanciare eccezione)
+		Entry<K, V> newest = new PQEntry<>(key, value);
+		list.addLast(newest);
+		return newest;
+	}
+
+	/** Restituisce una delle voci aventi chiave minima (senza rimuoverla). */
+	@Override
+	public Entry<K, V> min() {
+		if(list.isEmpty()) return null;
+		return findMin().getElement();
+	}
+
+	/** Elimina e restituisce una delle voci aventi chiave minima. */
+	@Override
+	public Entry<K, V> removeMin() {
+		if(list.isEmpty()) return null;
+		return list.remove(findMin());
+	}
+
+}