def priority_queue_test(a):
"""
-------------------------------------------------------
Tests priority queue implementation.
Use: Priority_Queue_test(a)
-------------------------------------------------------
Parameters:
a - list of data (list of ?)
Returns:
the methods of Priority_Queue are tested for both is_empty and
non-is_empty priority queues using the data in a:
is_empty, push, pop, peek
-------------------------------------------------------
"""
pq = Priority_Queue()
print("Priority Queue Initialised")
print()
print(SEP)
print("Priority Queue is_empty (expect True): {}".format(pq.is_empty()))
print("Priority Queue size (expect 0): {}".format(len(pq)))
print(SEP)
print("Add one item to Priority Queue")
pq.insert(a[0])
print("Front of Priority Queue (peek):")
print(pq.peek())
print(SEP)
print("Priority Queue is_empty (expect False): {}".format(pq.is_empty()))
print("Priority Queue size (expect 1): {}".format(len(pq)))
print(SEP)
print("Priority Queue remove")
v = pq.remove()
print(v)
print(SEP)
print("Priority Queue is_empty (expect True): {}".format(pq.is_empty()))
print("Priority Queue size (expect 0): {}".format(len(pq)))
print(SEP)
print("Copy all data to Priority Queue")
array_to_pq(pq, a)
print("Priority Queue is_empty (expect False): {}".format(pq.is_empty()))
print("Priority Queue size (expect > 0): {}".format(len(pq)))
print(SEP)
print("Front of Priority Queue (peek):")
print(pq.peek())
print(SEP)
print("Remove all elements from Priority Queue")
while not pq.is_empty():
v = pq.remove()
print(v)
print()
print(SEP)
print("Priority Queue is_empty (expect True): {}".format(pq.is_empty()))
print("Priority Queue size (expect 0): {}".format(len(pq)))
print()
return
def priority_queue_test(a):
"""
-------------------------------------------------------
Tests priority queue implementation.
Test the methods of Priority_Queue are tested for both empty and
non-empty priority queues using the data in a:
is_empty, insert, remove, peek
Use: pq_test(a)
-------------------------------------------------------
Parameters:
a - list of data (list of ?)
Returns:
None
-------------------------------------------------------
"""
pq = Priority_Queue()
print(pq.is_empty())
print("inserting 5:", pq.insert(5))
print("removing", pq.remove())
print("Peek:", pq.peek())
# tests for the priority queue methods go here
# print the results of the method calls and verify by hand
return None
def priority_queue_test(a):
"""
-------------------------------------------------------
Tests priority queue implementation.
Use: pq_test(a)
-------------------------------------------------------
Parameters:
a - list of data (list of ?)
Returns:
the methods of Priority_Queue are tested for both empty and
non-empty priority queues using the data in a:
is_empty, insert, remove, peek
-------------------------------------------------------
"""
pq = Priority_Queue()
print(pq.is_empty())
print(array_to_pq(pq, a))
print(pq.is_empty())
print(pq.peek())
a = pq.remove()
print(pq.peek())
pq.insert(a)
print(pq.peek())
print(pq.is_empty())
return
def prims(graph, start_node):
"""
-------------------------------------------------------
Applies Prim's Algorithm to a graph.
Use: edges, total = prims(graph, node)
-------------------------------------------------------
Parameters:
graph - graph to evaluate (Graph)
start_node - name of node to start evaluation from (str)
Returns:
edges - the list of the edges traversed (list of Edge)
total - total distance of all edges traversed (int)
-------------------------------------------------------
"""
pq = Priority_Queue()
total = 0
edges = []
nodes = []
nodes.append(start_node)
for edge in graph.edges_by_node(start_node):
pq.insert(edge)
while len(nodes) < len(graph):
edge = pq.remove()
node_name = edge.end
if node_name not in nodes:
nodes.append(node_name)
edges.append(edge)
total += edge.distance
for edge in graph.edges_by_node(node_name):
if edge.end not in nodes:
pq.insert(edge)
return edges, total
def priority_queue_test(a):
"""
-------------------------------------------------------
Tests priority queue implementation.
Test the methods of Priority_Queue are tested for both empty and
non-empty priority queues using the data in a:
is_empty, insert, remove, peek
Use: pq_test(a)
-------------------------------------------------------
Parameters:
a - list of data (list of ?)
Returns:
None
-------------------------------------------------------
"""
pq = Priority_Queue()
array_to_pq(pq, a)
print(pq.is_empty())
print(pq.peek())
print(pq.remove())
#print(pq.insert(1))
# print the results of the method calls and verify by hand
return
def levelorder(self):
"""
-------------------------------------------------------
Copies the contents of the tree in levelorder order to a list.
Use: values = bst.levelorder()
-------------------------------------------------------
Returns:
values - a list containing the values of bst in levelorder.
(list of ?)
-------------------------------------------------------
"""
node = self._root
if not node:
return
queue = Priority_Queue()
queue.insert(node)
traversal = []
while not queue.is_empty():
traversal.append(queue.peek())
node = queue.remove()
if node._left:
queue.insert(node._left)
if node._right:
queue.insert(node._right)
return traversal
def prims(graph, start_node):
"""
-------------------------------------------------------
Applies Prim's Algorithm to a graph.
Use: edges, total = prims(graph, node)
-------------------------------------------------------
Parameters:
graph - graph to evaluate (Graph)
start_node - name of node to start evaluation from (str)
Returns:
edges - the list of the edges traversed (list of Edge)
total - total distance of all edges traversed (int)
-------------------------------------------------------
"""
total = 0
edges = []
all_edges = Priority_Queue()
done_nodes = [start_node]
node_names = graph.node_names()
while len(done_nodes) != len(node_names):
done_nodes.append(start_node)
node_edges = graph.edges_by_node(start_node)
for edge in node_edges:
if edge.end() not in done_nodes:
all_edges.insert(edge)
ed = all_edges.remove()
while ed.end() in done_nodes and all_edges.is_empty() == False:
ed = all_edges.remove()
if all_edges.is_empty() == False:
edges.append(ed)
start_node = ed.end()
for i in edges:
total += i.distance
return edges, total
def priority_queue_test(a):
"""
-------------------------------------------------------
Tests priority queue implementation.
Use: pq_test(a)
-------------------------------------------------------
Parameters:
a - list of data (list of ?)
Returns:
the methods of Priority_Queue are tested for both empty and
non-empty priority queues using the data in a:
is_empty, insert, remove, peek
-------------------------------------------------------
"""
pq = Priority_Queue()
dummy = []
if pq.is_empty() == True:
print('pq is empty.')
array_to_pq(pq, a)
print('Converting a into a pq...')
if pq.is_empty() == False:
print('a has been transferred into pq!')
print('\nRemoving pq...')
while pq.is_empty() == False:
temp = pq.remove()
print(temp)
dummy.append(temp)
print('\pq is empty. Inserting values back into queue...')
while dummy != []:
temp = dummy.pop()
print(temp)
pq.insert(temp)
print('\nPushing complete! Peeking...')
print(pq.peek())
print('\npq is {} objects long!'.format(len(pq)))
return
def prims(graph, start_node):
"""
-------------------------------------------------------
Applies Prim's Algorithm to a graph.
Use: edges, total = prims(graph, node)
-------------------------------------------------------
Parameters:
graph - graph to evaluate (Graph)
start_node - name of node to start evaluation from (str)
Returns:
edges - the list of the edges traversed (list of Edge)
total - total distance of all edges traversed (int)
-------------------------------------------------------
"""
pq = Priority_Queue()
edges = []
total = 0
removed = [start_node]
names = graph.node_names()
current_edges = []
while len(removed) != len(names):
current_edges = graph.edges_by_node(start_node)
for edge in current_edges:
if edge.end() not in removed:
pq.insert(edge)
edge = pq.remove()
if edge.end() not in removed:
edges.append(edge)
total += edge.distance
removed.append(edge.end())
start_node = edge.end()
return edges, total
def prims(graph, start_node):
"""
-------------------------------------------------------
Applies Prim's Algorithm to a graph.
Use: edges, total = prims(graph, node)
-------------------------------------------------------
Parameters:
graph - graph to evaluate (Graph)
start_node - name of node to start evaluation from (str)
Returns:
edges - the list of the edges traversed (list of Edge)
total - total distance of all edges traversed (int)
-------------------------------------------------------
"""
edges = []
total = 0
nodes_visited = []
pq = Priority_Queue()
current_node = start_node
while len(nodes_visited) != len(graph):
if current_node not in nodes_visited:
nodes_visited.append(current_node)
node_edges = graph.edges_by_node(current_node)
for e in node_edges:
if not (e.start() in nodes_visited and e.end() in nodes_visited):
pq.insert(e)
edge_to_add = pq.remove()
already_in = edge_to_add.start() in nodes_visited and edge_to_add.end(
) in nodes_visited
if not already_in:
edges.append(edge_to_add)
total += edge_to_add.distance
current_node = edge_to_add.end()
return edges, total
def priority_queue_test(a):
"""
-------------------------------------------------------
Tests priority queue implementation.
Use: pq_test(a)
-------------------------------------------------------
Parameters:
a - list of data (list of ?)
Returns:
the methods of Priority_Queue are tested for both empty and
non-empty priority queues using the data in a:
is_empty, insert, remove, peek
-------------------------------------------------------
"""
pq = Priority_Queue()
# tests for the priority priority queue methods go here
# print the results of the method calls and verify by hand
# Test if priority queue is empty (Expected: TRUE)
print("priority queue contents: ")
for i in pq:
print(i, end=' ')
print("\tEmpty? {}".format(pq.is_empty()))
# Load elements from a into priority queue
print(">> Insert elements into a onto priority queue")
print(">> Num elements to insert: {}".format(len(a)))
for elem in a:
pq.insert(elem)
# Check if the priority queue is empty again (T/F depending on a contents)
print("priority queue contents: ")
for i in pq:
print(i, end=' ')
print("\tEmpty? {}".format(pq.is_empty()))
# Peek the top of the priority queue
top = None
try:
top = pq.peek()
except:
print(">>! Peeked at an empty priority queue, assertion caught, continuing...")
# Check if top of priority queue is the end element of a
print("Top of priority queue should be same as beginning of list")
highest_priority = 0
if pq.is_empty():
print("List empty so no check")
else:
for i in range(len(a)):
if a[i] < a[highest_priority]:
highest_priority = i
priority_same = (top == a[highest_priority])
print("Highest priority same as smallest in list?")
print("Top: \n{}\tFront of list: \n{}".format(top, a[highest_priority]))
print("Same? {}".format(priority_same))
# Testing pop
#try:
print(">> Remove top of priority queue")
popped = pq.remove()
print("Removed value from pq: \n{}\tLowest value of list: \n{}".format(popped, a[highest_priority]))
print("Removed value should be same as lowest value of list.\tSame? {}".format(popped == a[highest_priority]))
#except:
#print(">>! Removed from an empty priority queue, exception caught, continuing...")
return
def main():
pq = Priority_Queue()
pq.insert(3)
pq.insert(2)
r = pq.remove()
print(r)
""" ------------------------------------------------------------------------ [program description] ------------------------------------------------------------------------ Author: Nicolas Mills ID: 180856100 Email: [email protected] __updated__ = 2019-01-28 ------------------------------------------------------------------------ """ from Priority_Queue_array import Priority_Queue pq = Priority_Queue() values = [66, 55, 44, 33, 22, 11] for i in values: pq.insert(i) removed = pq.remove() print("removed: {}\tpeeked: {}".format(removed, pq.peek())) assert pq.peek() == values[-2]
