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)
