class SortedPriorityQueue(PriorityQueueBase): """ A priority queue class storing elements sorted according to priority """ def __init__(self): self._data = PositionalList() def __len__(self): return len(self._data) def min(self): if self.is_empty(): raise EmptyException('Priority queue is empty.') p = self._data.first() return (p.element()._key, p.element()._value) def remove_min(self): if self.is_empty(): raise EmptyException('Priority queue is empty.') p = self._data.first() item = self._data.delete(p) return (item._key, item._value) def add(self, k, v): newest = self._Item(k, v) walk = self._data.last() while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: self._data.add_first(newest) else: self._data.add_after(walk, newest)
class SortedPriorityQueue(PriorityQueueBase): def __init__(self): self._data = PositionalList() def __len__(self): return len(self._data) def add(self, key, value): new = self._Item(key, value) walk = self._data.last() while walk is not None and new < walk.element(): walk = self._data.before(walk) if walk is None: self._data.add_first(new) else: self._data.add_before(walk, new) def min(self): if self.is_empty(): raise Empty('Priority queue is empty.') p = self._data.first() item = p.element() return item._key, item._value def remove_min(self): if self.is_empty(): raise Empty('Priority queue is empty.') item = self._data.delete(self._data.first()) return item._key, item._value
class SortedPriorityQueue(PriorityQueueBase): # base class defines _Item """ A min-oriented priority queue implemented with a sorted list. """ def __init__(self): """ Create a new empty Priority Queue. """ self._data = PositionalList() def __len__(self): """ Return the num of items in the priority queue. """ return len(self._data) def add(self, key, value): """ Add a key-value pair. """ newest = self._Item(key, value) # make new item instance walk = self._data.last() # walk backward looking for smaller key while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: self._data.add_first(newest) # new key is smallest else: self._data.add_after(walk, newest) # newest goes after walk def min(self): """ Return but do not remove (k,v) tuple with min key """ if self.is_empty(): raise Exception('Priority queue is empty.') p = self._data.first() item = p.element() return (item._key, item._value) def remove_min(self): """ Remove and return (k,v) tuple with min key. """ if self.is_empty(): raise Exception('Priority queue is empty.') item = self._data.delete(self._data.first()) return (item._key, item._value)
class SortedPriorityQueue(PriorityQueueBase): def __init__(self): self._data = PositionalList() def __len__(self): return len(self._data) def add(self, key, value): newest = self._Item(key, value) walk = self._data.last() while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: self._data.add_first(newest) else: self._data.add_after(walk, newest) def min(self): if self.is_empty(): raise Empty('Priority queue is empty') p = self._data.first() item = p.element() return (item._key, item._value) def remove_min(self): if self.is_empty(): raise Empty('Priority queue is empty') item = self._data.delete(self._data.first()) return (item._key, item._value)
class sortedPriorityQueue(PriorityQueueBase): # base class defines _Item """A min-oriented priority queue implemented with an unsorted list.""" #----------------------------- nonpublic behavior ----------------------------- #------------------------------ public behaviors ------------------------------ def __init__(self): """Create a new empty Priority Queue.""" self._data = PositionalList() def __len__(self): """Return the number of items in the priority queue.""" return len(self._data) def add(self, key, value): """Add a key-value pair.""" newest = self._Item(key, value) walk = self._data.last() while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: self._data.add_first(newest) else: self._data.add_after(walk, newest) def min(self): """Return but do not remove (k,v) tuple with minimum key. Raise Empty exception if empty. """ if self.is_empty(): raise Exception("Priority queue is empty") p = self._data.first() item = p.element() return (item._key, item._value) def remove_min(self): """Remove and return (k,v) tuple with minimum key. Raise Empty exception if empty. """ if self.is_empty(): raise Exception("Priority Queue is empty.") item = self._data.delete(self._data.first()) return (item._key) def __iter__(self): """Generate iteration of the map's keys.""" for item in self._data: yield item # yield the KEY def insertionSort(self, A): for i in A: self.add(i, i) for i in range(len(A)): A[i] = self.remove_min()
class SortedPriorityQueue(PriorityQueue): """ Implementation of a PriorityQueue using a sorted PositionalList Adds items to the list in order """ def __init__(self): """ Creates an empty PriorityQueue """ self._data = PositionalList() def __len__(self): """ returns: the number of items in the PriorityQueue """ return len(self._data) def add(self, key, value): """ Adds a key-value pair to the PriorityQueue """ new_item = self._Item(key, value) walk = self._data.last() while walk is not None and new_item < walk.element(): walk = self._data.before(walk) if walk is not None: self._data.add_after(walk, new_item) else: self._data.add_first(new_item) def min(self): """ returns: the (k,v) tuple with the minimum key, without removing it """ if self.is_empty(): raise Empty('Priority Queue is empty') p = self._data.first() item = p.element() return (item._key, item._value) def remove_min(self): """ removes the minimum (k,v) tuple from the priority queue returns: the (k,v) tuple """ if self.is_empty(): raise Empty('Priority Queue is empty') p = self._data.first() item = self._data.delete(p) return (item._key, item._value)
class SortedPriorityQueue(PriorityQueueBase): # base class defines _Item """A min-oriented priority queue implemented with a sorted list.""" # ------------------------------ public behaviors ------------------------------ def __init__(self): """Create a new empty Priority Queue.""" self._data = PositionalList() def __len__(self): """Return the number of items in the priority queue.""" return len(self._data) def add(self, key, value): """Add a key-value pair.""" newest = self._Item(key, value) walk = self._data.last() # walk backward look for smaller while walk and newest < walk.element(): walk = self._data.before(walk) if not walk: self._data.add_first(newest) else: self._data.add_after(walk, newest) def min(self): """Return but do not remove (k,v) tuple with minimum key. Raise Empty exception if empty. """ if self.is_empty(): raise Empty('Priority Queue is empty') first = self._data.first() item = first.element() return (item._key, item._value) def remove_min(self): """Remove and return (k,v) tuple with minimum key. Raise Empty exception if empty. """ min = self._data.first() item = self._data.delete(min) return (item._key, item._value)
class SortedPriorityQueue(PriorityQueueBase): # base class defines _Item """A min-oriented priority queue implemented with a sorted list.""" #------------------------------ public behaviors ------------------------------ def __init__(self): """Create a new empty Priority Queue.""" self._data = PositionalList() def __len__(self): """Return the number of items in the priority queue.""" return len(self._data) def add(self, key, value): """Add a key-value pair.""" newest = self._Item(key, value) # make new item instance walk = self._data.last() # walk backward looking for smaller key while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: self._data.add_first(newest) # new key is smallest else: self._data.add_after(walk, newest) # newest goes after walk def min(self): """Return but do not remove (k,v) tuple with minimum key. Raise Empty exception if empty. """ if self.is_empty(): raise Empty('Priority queue is empty.') p = self._data.first() item = p.element() return (item._key, item._value) def remove_min(self): """Remove and return (k,v) tuple with minimum key. Raise Empty exception if empty. """ if self.is_empty(): raise Empty('Priority queue is empty.') item = self._data.delete(self._data.first()) return (item._key, item._value)
class SortedPriorityQueue(PriorityQueueBase): def __init__(self): #empty priority queue self._data = PositionalList() def __len__(self): #number of items in priority queue return len(self._data) def add(self, key, value): #add key-value pair #._Item defined by base class newest = self._Item(key, value) walk = self._data.last() #look for smaller key while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: self._data.add_first(newest) else: self._data.add_after(walk, newest) def min(self): #returns but does not remove the tuple with min key if self.is_empty(): raise Empty('Priority queue is empty.') p = self._data.first() item = p.element() return (item._key, item._value) def remove_min(self): #removes and returns the tuple with minimum key if self.is_empty(): raise Empty('Priority queue is empty') item = self._data.delete(self._data.first()) return (item._key) def __iter__(self): #iteration of the map's keys for item in self._data: yield item
class SortedListPQ(PriorityQueueBase): # base class defines _Item """A min-oriented priority queue implemented with an unsorted list.""" def __init__(self): """Create a new empty Priority Queue.""" self._data = PositionalList() def __len__(self): """Return the number of items in the priority queue.""" return len(self._data) def add(self, key, value): """Add a key-value pair.""" newest = self._Item(key, value) walk = self._data.last() while walk is not None and newest < walk.element(): walk = self._data.before(walk) if walk is None: self._data.add_first(newest) else: self._data.add_after(walk, newest) def min(self): """Return but do not remove (k,v) tuple with minimum key. Raise Empty exception if empty. """ if self.is_empty(): raise Empty("Priority queue is empty") p = self._data.first() item = p.element() return item._key, item._value def remove_min(self): """Remove and return (k,v) tuple with minimum key. Raise Empty exception if empty. """ if self.is_empty(): raise Empty("Priority queue is empty") item = self._data.delete(self._data.first()) return (item._key, item._value)