def test_inf_queue(self):
queue = ArrayQueue()
queue.enqueue(1)
queue.enqueue(2)
assert queue.is_empty() == False
assert queue.is_full() == False
assert queue.capacity == float('inf')
assert queue.__repr__() == 'ArrayQueue: front [1,2] tail'
assert len(queue) == 2
assert queue.front() == 1
assert queue.dequeue() == 1
assert queue.is_empty() == False
assert queue.is_full() == False
assert queue.capacity == float('inf')
assert queue.__repr__() == 'ArrayQueue: front [2] tail'
assert len(queue) == 1
assert queue.front() == 2
assert queue.dequeue() == 2
assert queue.is_empty() == True
assert queue.is_full() == False
assert queue.capacity == float('inf')
assert queue.__repr__() == 'ArrayQueue: front [] tail'
assert len(queue) == 0
with pytest.raises(EmptyError):
queue.front()
with pytest.raises(EmptyError):
queue.dequeue()
def test_array_queue():
array_queue = ArrayQueue()
# Assert that we start with an empty queue
assert array_queue.is_empty()
with pytest.raises(Empty):
array_queue.first()
# Enqueue a bunch of elements into the back of the queue
for i in range(10):
array_queue.enqueue(i)
array_queue, first = array_queue.first()
assert first == 0
assert len(array_queue) == i + 1
# Dequeue a bunch of elements from the front of the queue
for i in range(10):
array_queue, val = array_queue.dequeue()
assert val == i
assert len(array_queue) == 10 - 1 - i
# Assert we are back to an empty queue
assert array_queue.is_empty()
with pytest.raises(Empty):
array_queue.dequeue()
class StockTracker: #set constructor as an empty object def __init__(self): self._total_qty = 0 self._profit = 0.0 self._arque = ArrayQueue() #buy stock. quantity must be greater than 0 and price must be a floating point number otherwise error occurs def buy ( self, quantity, price ): assert ( quantity > 0 ), 'quantity needs to be a positive integer' assert ( price > 0 ), 'price needs to be a positive floating point number' assert ( type( price ) is float ), 'price needs to be a positive floating point number' self._arque.enqueue( ( quantity, price ) ) self._total_qty += quantity #sell stock. quantity must be greater than 0, price must be floating point number, #quantity must be less than or equal to the quantity on hand other wise error occurs def sell ( self, quantity, price ): assert ( quantity > 0 ), 'quantity needs to be a positive integer' assert ( price > 0 ), 'price needs to be a positive floating point number' assert ( type( price ) is float ), 'type must be float' assert ( quantity <= self.getQuantityOnHand() ), 'quantity needs to be less than or equal to the total number of shares on hand' selling = 0 while quantity > 0: transaction = self._arque.dequeue() #Deque value amount = transaction[ 0 ] #Parse value value = transaction[ 1 ] if quantity >= amount: #Make sure the specific transaction has enough to fill the order selling += amount * ( price - value ) #Calculate the profit self._total_qty -= amount #Update remaining shares sell else: selling += quantity * ( price - value ) self._total_qty -= quantity self._arque.enqueue( ( amount - quantity, value ) ) #Re-add what is left of this transaction while self._arque.first() != ( amount - quantity, value ): #Send it back to the front self._arque.enqueue( self._arque.dequeue() ) quantity -= amount self._profit += selling return selling #returns total gain or loss since creating the empty object def getProfit (self): return self._profit #returns the quantity of shares on hand def getQuantityOnHand (self): return self._total_qty
class ShopTracker:
def __init__(self):
self._listQueue = ArrayQueue()
def startDay(self):
""" Starts the day off by starting the listing process """
alpha = raw_input("Please enter the name (Enter End when done): ")
while alpha != "End":
self._listQueue.enqueue(alpha)
alpha = raw_input("Please enter the name (Enter End when done): ")
print len(self._listQueue) , "client(s) left"
def addMore(self):
""" Restarts the listing process again to add more names """
alpha = raw_input("Please enter the name (Enter End when done): ")
while alpha != "End":
alpha = raw_input("Please enter the name (Enter End when done): ")
self._listQueue.enqueue(alpha)
print len(self._listQueue) , "client(s) left"
def endDay(self):
""" Ends the day by clearing out the queue"""
while len(self._listQueue) != 0:
self._listQueue.dequeue()
print len(self._listQueue) , "client(s) left"
def getLength(self):
""" Return length of elements in queue """
return len(self._listQueue)
def primero(self):
""" Prints out the first name in the queue (will not remove) """
if len(self._listQueue) == 0:
#raise Empty('Queue is empty')
print "You have no client(s) left"
else:
return self._listQueue.first()
def getNext(self):
""" Return the first name in the queue (will remove) """
if len(self._listQueue) == 0:
#raise Empty('Queue is empty')
print "You have no client(s) left"
else:
return self._listQueue.dequeue()
def test_fix_len_queue(self):
queue = ArrayQueue(3)
queue.enqueue(1)
queue.enqueue(2)
assert queue.is_empty() == False
assert queue.is_full() == False
assert queue.capacity == 3
assert queue.__repr__() == 'ArrayQueue: front [1,2] tail'
assert len(queue) == 2
assert queue.front() == 1
queue.enqueue(3)
assert queue.is_empty() == False
assert queue.is_full() == True
assert queue.capacity == 3
assert queue.__repr__() == 'ArrayQueue: front [1,2,3] tail'
assert len(queue) == 3
assert queue.front() == 1
with pytest.raises(FullError):
queue.enqueue(4)
assert queue.dequeue() == 1
assert queue.is_empty() == False
assert queue.is_full() == False
assert queue.capacity == 3
assert queue.__repr__() == 'ArrayQueue: front [2,3] tail'
assert len(queue) == 2
assert queue.front() == 2
class ShopTracker:
def __init__(self):
self._listQueue = ArrayQueue()
def startDay(self):
""" Starts the day off by starting the listing process """
alpha = raw_input("Please enter the name (Enter End when done): ")
while alpha != "End":
self._listQueue.enqueue(alpha)
alpha = raw_input("Please enter the name (Enter End when done): ")
print len(self._listQueue), "client(s) left"
def addMore(self):
""" Restarts the listing process again to add more names """
alpha = raw_input("Please enter the name (Enter End when done): ")
while alpha != "End":
alpha = raw_input("Please enter the name (Enter End when done): ")
self._listQueue.enqueue(alpha)
print len(self._listQueue), "client(s) left"
def endDay(self):
""" Ends the day by clearing out the queue"""
while len(self._listQueue) != 0:
self._listQueue.dequeue()
print len(self._listQueue), "client(s) left"
def getLength(self):
""" Return length of elements in queue """
return len(self._listQueue)
def primero(self):
""" Prints out the first name in the queue (will not remove) """
if len(self._listQueue) == 0:
#raise Empty('Queue is empty')
print "You have no client(s) left"
else:
return self._listQueue.first()
def getNext(self):
""" Return the first name in the queue (will remove) """
if len(self._listQueue) == 0:
#raise Empty('Queue is empty')
print "You have no client(s) left"
else:
return self._listQueue.dequeue()
def breadthfirst(self):
"""Generate a breadth-first iteration of the positions of the alberi."""
if not self.is_empty():
fringe = ArrayQueue() # known positions not yet yielded
fringe.enqueue(self.root()) # starting with the root
while not fringe.is_empty():
p = fringe.dequeue() # remove from front of the queue
yield p # report this position
for c in self.children(p):
fringe.enqueue(c) # add children to back of queue
def test_fix_len_empty_queue(self):
queue = ArrayQueue(0)
assert queue.is_empty() == True
assert queue.is_full() == True
assert queue.capacity == 0
assert queue.__repr__() == 'ArrayQueue: front [] tail'
assert len(queue) == 0
with pytest.raises(EmptyError):
queue.front()
with pytest.raises(EmptyError):
queue.dequeue()
with pytest.raises(FullError):
queue.enqueue(1)
queue = ArrayQueue(3)
assert queue.is_empty() == True
assert queue.is_full() == False
assert queue.capacity == 3
assert queue.__repr__() == 'ArrayQueue: front [] tail'
assert len(queue) == 0
with pytest.raises(EmptyError):
queue.front()
with pytest.raises(EmptyError):
queue.dequeue()
start_time = time.time()
for i in range(0, n):
LLQ.enqueue(i)
end_time = time.time()
print(f"LLQueue time to enqueue: {end_time - start_time} seconds")
start_time = time.time()
for i in range(0, n):
DQ.append(i)
end_time = time.time()
print(f"Deque time to enqueue: {end_time - start_time} seconds")
start_time = time.time()
for i in range(0, n):
AQ.dequeue()
end_time = time.time()
print(f"Array Queue time to dequeue: {end_time - start_time} seconds")
start_time = time.time()
for i in range(0, n):
LLQ.dequeue()
end_time = time.time()
print(f"LLQueue time to dequeue: {end_time - start_time} seconds")
start_time = time.time()
for i in range(0, n):
DQ.popleft()
end_time = time.time()
print(f"Deque time to dequeue: {end_time - start_time} seconds")
# Description:
# use queue to change [1,2,3,4,5,6,7,8] into
# [1,2,3,5,4,6,7,8]
# Last Modified:
# 2014-06-27 11:08:05
from array_queue import ArrayQueue
if __name__ == '__main__':
D = ArrayQueue()
Q = ArrayQueue()
#initial D
for i in range(1, 9):
D.enqueue(i)
D.enqueue(D.dequeue())
D.enqueue(D.dequeue())
D.enqueue(D.dequeue()) # D = [4,5,6,7,8,1,2,3]
Q.enqueue(D.dequeue()) # Q = [4], D = [5,6,7,8,1,2,3]
D.enqueue(D.dequeue()) # Q = [4], D = [6,7,8,1,2,3,5]
D.enqueue(Q.dequeue()) # Q = [], D = [6,7,8,1,2,3,5,4]
D.enqueue(D.dequeue())
D.enqueue(D.dequeue())
D.enqueue(D.dequeue()) # D = [1,2,3,5,4,6,7,8]
for i in range(8):
print(D.dequeue(), end=',')
class Graph:
"""Representation of a simple graph using an adjacency map."""
#------------------------- nested Vertex class -------------------------
class Vertex:
"""Lightweight vertex structure for a graph."""
__slots__ = '_element'
def __init__(self, x):
"""Do not call constructor directly. Use Graph's insert_vertex(x)."""
self._element = x
def element(self):
"""Return element associated with this vertex."""
return self._element
def __hash__(self): # will allow vertex to be a map/set key
return hash(id(self))
def __str__(self):
return str(self._element)
def __eq__(self, other):
return str(self) == str(other)
def __repr__(self):
return str(self._element)
#------------------------- nested Edge class -------------------------
class Edge:
"""Lightweight edge structure for a graph."""
__slots__ = '_origin', '_destination', '_element'
def __init__(self, u, v, x):
"""Do not call constructor directly. Use Graph's insert_edge(u,v,x)."""
self._origin = u
self._destination = v
self._element = x
def endpoints(self):
"""Return (u,v) tuple for vertices u and v."""
return (self._origin, self._destination)
def opposite(self, v):
"""Return the vertex that is opposite v on this edge."""
if not isinstance(v, Graph.Vertex):
raise TypeError('v must be a Vertex')
return self._destination if v is self._origin else self._origin
raise ValueError('v not incident to edge')
def element(self):
"""Return element associated with this edge."""
return self._element
def __hash__(self): # will allow edge to be a map/set key
return hash((self._origin, self._destination))
def __str__(self):
return '({0},{1},{2})'.format(self._origin, self._destination,
self._element)
def __eq__(self, other):
return str(self) == str(other)
def __repr__(self):
return '({0},{1},{2})'.format(self._origin, self._destination,
self._element)
#------------------------- Graph methods -------------------------
def __init__(self, directed=False):
"""Create an empty graph (undirected, by default).
Graph is directed if optional paramter is set to True.
"""
self._outgoing = {}
# only create second map for directed graph; use alias for undirected
self._incoming = {} if directed else self._outgoing
self.directed = directed
def _validate_vertex(self, v):
"""Verify that v is a Vertex of this graph."""
if not isinstance(v, self.Vertex):
raise TypeError('*Vertex expected')
if v not in self._outgoing:
raise ValueError('*Vertex does not belong to this graph.')
def _validate_edge(self, e): #validating the edge
"""Verify that e is an Edge of this graph."""
if not isinstance(e, self.Edge):
raise TypeError('*Edge expected')
def is_directed(self):
"""Return True if this is a directed graph; False if undirected.
Property is based on the original declaration of the graph, not its contents.
"""
return self._incoming is not self._outgoing # directed if maps are distinct
def vertex_count(self):
"""Return the number of vertices in the graph."""
return len(self._outgoing)
def vertices(self):
"""Return an iteration of all vertices of the graph."""
return self._outgoing.keys()
def edge_count(self):
"""Return the number of edges in the graph."""
total = sum(len(self._outgoing[v]) for v in self._outgoing)
# for undirected graphs, make sure not to double-count edges
return total if self.is_directed() else total // 2
def edges(self):
"""Return a set of all edges of the graph."""
result = set() # avoid double-reporting edges of undirected graph
for secondary_map in self._outgoing.values():
result.update(secondary_map.values()) # add edges to resulting set
return result
def get_edge(self, u, v):
"""Return the edge from u to v, or None if not adjacent."""
self._validate_vertex(u)
self._validate_vertex(v)
return self._outgoing[u].get(v) # returns None if v not adjacent
def degree(self, v, outgoing=True):
"""Return number of (outgoing) edges incident to vertex v in the graph.
If graph is directed, optional parameter used to count incoming edges.
"""
self._validate_vertex(v)
adj = self._outgoing if outgoing else self._incoming
return len(adj[v])
def incident_edges(self, v, outgoing=True):
"""Return all (outgoing) edges incident to vertex v in the graph.
If graph is directed, optional parameter used to request incoming edges.
"""
self._validate_vertex(v)
adj = self._outgoing if outgoing else self._incoming
for edge in adj[v].values():
yield edge
def insert_vertex(self, x=None):
"""Insert and return a new Vertex with element x."""
v = self.Vertex(x)
self._outgoing[v] = {}
if self.is_directed():
self._incoming[v] = {} # need distinct map for incoming edges
return v
def insert_edge(self, u, v, x=None):
"""Insert and return a new Edge from u to v with auxiliary element x.
Raise a ValueError if u and v are not vertices of the graph.
Raise a ValueError if u and v are already adjacent.
"""
if self.get_edge(u, v) is not None: # includes error checking
raise ValueError('u and v are already adjacent')
e = self.Edge(u, v, x)
self._outgoing[u][v] = e
self._incoming[v][u] = e
def remove_vertex(self, v):
"""Remove the vertex v and all its incident edges,
and return the vertex been removed.
Parameter v is an instance of Vertex
Algorithm should run in O(deg(v)) time
"""
self._validate_vertex(v) #validating vertex u
edges = list(self.incident_edges(v, False)) if self.directed else list(
self.incident_edges(v))
for edge in edges: #deleting incident edges of v
self.remove_edge(edge) #removing each edge
del self._outgoing[v] #deleting the vertex
return v
def remove_edge(self, e):
"""remove the edge e from the adjacency map for each
incident vertex, and return the edge removed.
Parameter e is an instance of Edge
Algorithm should run in O(1) time.
"""
self._validate_edge(e) #validating the receive edge
u, v = e.endpoints() #getting the endpoints from edge instance
self._validate_vertex(u) #validating vertex u
self._validate_vertex(v) #validating vertex v
#deleting the v to u edge if it undirected graph, and if edge v to u exists on this undirected graph
if not self.directed and self._outgoing[v][u]:
del self._outgoing[v][u]
del self._outgoing[u][v] #deleting the edge received
return e
def bfs_traversal(self):
"""implement a Breadth-First Search method inside the
class Graph, use a FIFO queue rather than a level-by-level formulation
to manage vertices that have been discovered until the time when their
neighbors are considered. Return a map of vertices and the edges that
those vertices are discovered.
"""
try:
key, v = next(iter(
self._outgoing.items())) #Gettig the starting key
print("the starting vetrice = ",
key) #displaying the starting vertice
self.empty = ArrayQueue(
) #creating empty queue to enqueue and dequeue
visited = [] #Empty list to keep track of the visited vertices
visited.append(key) #Adding the starting Vertex to queue
self.empty.enqueue(
key) # Adding the starting Vertex to visited list
print(key, " ", None) #The first vertice is visited by none
while self.empty._size > 0: #checking the length of the queue
key = self.empty.dequeue() #setting the pointer node
for x in (self.incident_edges(key)
): #getting incident edges for vertex
other_end = x.opposite(
key) #getting the opposite vertice on that edge
if other_end not in visited: #checking if the vertex has been visited
print(other_end, " ",
(key, other_end, x.element()
)) #printing when the vertex was discovered
self.empty.enqueue(
other_end
) #appending the both the queue and cisited list
visited.append(other_end)
except TypeError:
print("The vortex doesn't exit.")
def print_graph(self):
"""this method should print all vertices with their
incident edges.
"""
if len(self._outgoing) > 0:
for key, nested in self._outgoing.items():
print(key, list(nested.values()))
else:
raise ValueError
