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): """ 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): 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)
def top(self, k): if k < 1 or k > len(self._data): raise ValueError("Invalid value for k.") tmp = PositionalList() for i in range(len(self._data)): tmp.add_first(self._data.delete(self._data.first())) for i in range(k): p = tmp.first() p_max = tmp.first() max = p.element()._value while p != None: if p.element()._value > max: p = self._data.after(p) p_max = p.element() max = p_max._value yield max
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)
from heap_priority_queue import HeapPriorityQueue def pq_sort(C): """Sort a collection of elements stored in a positional list.""" n = len(C) P = HeapPriorityQueue() # use heap implementation for j in range(n): element = C.delete(C.first()) P.add(element, element) # use element as key and value for j in range(n): (k, v) = P.remove_min() C.add_last(v) # store smallest remaining element in C if __name__ == "__main__": C = PositionalList() C.add_first(1) C.add_first(3) C.add_first(2) C.add_first(20) C.add_last(-50) C.add_last(-50) C.add_last(1) C.add_last(4) print(len(C)) print("Before sort:") print_positional_list(C) pq_sort(C) print("After sort:") print_positional_list(C) clear_positional_list(C) print_positional_list(C)
# -*- coding: utf-8 -*- from positional_list import PositionalList def max(pl): """ Return the max element of the positional list pl. Return None if the list is empty.""" if pl.is_empty(): return None rlt = pl.first().element() for item in pl: if item > rlt: rlt = item.element() return rlt if __name__ == '__main__': pl = PositionalList() for i in range(10000): pl.add_first(i) print('max: {0:d}'.format(max(pl)))
from random import shuffle def bubble_sort(pl): """ Bubble sort for positional sort.""" length = len(pl) if length == 0: return for i in range(length - 1, -1, -1): walk = pl.first() nxt = pl.after(walk) for j in range(i): if walk.element() > nxt.element(): pl.swap(walk, nxt) nxt = pl.after(walk) else: walk = nxt nxt = pl.after(nxt) return if __name__ == '__main__': pl = PositionalList() llen = 20 l = [i for i in range(llen)] shuffle(l) for i in range(llen): pl.add_first(l[i]) # initialize pl to decreasing order print(pl) bubble_sort(pl) print(pl)
insertion_sort(PL) print('After sort:') print_positional_list(PL) # Insertion sort test 4 print() print('Before sort:') print_positional_list(PL) insertion_sort(PL) print('After sort:') print_positional_list(PL) # Insertion sort test 5 print() clear_positional_list(PL) PL.add_first(10) print('Before sort:') print_positional_list(PL) insertion_sort(PL) print('After sort:') print_positional_list(PL) # Insertion sort test 6: Empty list print() clear_positional_list(PL) print('Before sort:') print_positional_list(PL) insertion_sort(PL) print('After sort:') print_positional_list(PL)