def bf_traverse(self):
q = ArrayQueue()
if self.r != self.nil: q.add(self.r)
while q.size() > 0:
u = q.remove()
if u.left != self.nil: q.add(u.left)
if u.right != self.nil: q.add(u.right)
def bf_traverse(self):
q = ArrayQueue()
if self.r != self.nil: q.add(self.r)
while q.size() > 0:
u = q.remove()
if u.left != self.nil: q.add(u.left)
if u.right != self.nil: q.add(u.right)
def test_ArrayQueue_dequeue(self):
queue = ArrayQueue()
for i in range(100):
queue.enqueue(i + 1)
for i in range(100):
assert_equal(i + 1, queue.dequeue())
assert_equal(99 - i, len(queue))
assert_equal(0, len(queue))
def stack_to_queue(stack):
"""
Converts the stack to a queue.
"""
q = ArrayQueue()
for i in list(stack)[::-1]:
q.add(i)
return q
def stack_to_queue(stack):
"""
Convert stack to queue
"""
queue = ArrayQueue()
while len(stack) != 0:
num = stack.pop()
queue.add(num)
return queue
def __init__(self, number):
"""Maintains a cashier number, a queue of customers,
number of customers served, total customer wait time,
and a current customer being processed."""
self._number = number
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = ArrayQueue()
def stackToQueue(stack):
stack_copy = copy.deepcopy(stack)
queue = ArrayQueue()
while True:
try:
queue.add(stack_copy.pop())
except KeyError:
break
return queue
def stack_to_queue(stack):
'''
Conver stack to queue.
'''
stack_copy = deepcopy(stack)
queue = ArrayQueue()
while stack_copy:
queue.add(stack_copy.pop())
return queue
def stack_to_queue(stack):
"""Converts stack to a queue"""
start_stack = copy.deepcopy(stack)
output_queue = ArrayQueue()
while start_stack.isEmpty() is False:
elem = start_stack.pop()
output_queue.add(elem)
return output_queue
def queue_to_stack(queue):
'''Convert queue to stack, without modifying the queue
peek of the stack must be first element of the queue'''
stack = ArrayStack()
queue_copy = ArrayQueue(queue)
while len(queue_copy) != 0:
stack.push(queue_copy.remove(len(queue_copy) - 1))
return stack
def stack_to_queue(stack):
'''Convert stack to queue, without changing given stack
peek of the stack is the first element in the queue'''
queue = ArrayQueue()
stack_copy = ArrayStack(stack)
while len(stack_copy) != 0:
queue.add(stack_copy.pop())
return queue
def stack_to_queue(stack):
copied = copy(stack)
# print(copied)
the_queue = ArrayQueue()
future_queue = []
while True:
try:
future_queue.append(copied.pop())
except KeyError:
return ArrayQueue(future_queue)
def stack_to_queue(stack: ArrayStack) -> ArrayQueue:
"""
Converts stack to queue and returns Queue object
"""
queue = ArrayQueue()
copy_of_stack = deepcopy(stack)
while not copy_of_stack.isEmpty():
queue.add(copy_of_stack.pop())
return queue
def stack_to_queue(stack):
"""
Converts stack to queue.
"""
list_stack = []
for i in stack:
list_stack.append(i)
list_queue = list_stack[::-1]
new_queue = ArrayQueue()
for j in range(len(list_stack)):
new_queue.add(list_queue[j])
return new_queue
def test_ArrayQueue_multipleoperations(self):
queue = ArrayQueue()
for i in range(100):
queue.enqueue(i + 100)
for i in range(50):
queue.dequeue()
for i in range(100):
queue.enqueue(i + 200)
assert_equal(150, queue.front())
def stack_to_queue(stack):
"""
Converts stack to queue.
"""
temp_stack = ArrayStack()
result_queue = ArrayQueue()
while not stack.isEmpty():
elem = stack.pop()
result_queue.add(elem)
temp_stack.push(elem)
while not temp_stack.isEmpty():
stack.push(temp_stack.pop())
return result_queue
def stack_to_queue(stack):
"""
Return queue from stack (front of queue is peek of stack).
"""
copy_stack = ArrayStack()
queue = ArrayQueue()
for element in stack:
copy_stack.push(element)
while len(copy_stack) != 0:
queue.add(copy_stack.pop())
return queue
class Cashier(object):
"""Represents a cashier."""
def __init__(self, number):
"""Maintains a cashier number, a queue of customers,
number of customers served, total customer wait time,
and a current customer being processed."""
self._number = number
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = ArrayQueue()
def addCustomer(self, c):
"""Adds an arriving customer to my line."""
self._queue.add(c)
def serveCustomers(self, currentTime):
"""Serves my cuatomers during a given unit of time."""
if self._currentCustomer is None:
# No customers yet
if self._queue.isEmpty():
return
else:
# Pop first waiting customer and tally results
self._currentCustomer = self._queue.pop()
self._totalCustomerWaitTime += \
currentTime - \
self._currentCustomer.arrivalTime()
self._customersServed += 1
# Give a unit of service
self._currentCustomer.serve()
# If current customer is finished, send it away
if self._currentCustomer.amountOfServiceNeeded() == 0:
self._currentCustomer = None
def __str__(self):
"""Returns my results: my number, my total customers served,
my average wait time per customer, and customers left on my queue."""
if self._customersServed != 0:
aveWaitTime = float(self._totalCustomerWaitTime) /\
self._customersServed
else:
aveWaitTime = 0.0
result = "%4d %8d %13.2f %8d" % (self._number,
self._customersServed,
aveWaitTime,
len(self._queue))
return result
def __init__(self, numAgents, numMinutes, betweenTime, serviceTime):
# Parameters supplied by the user.
self._arriveProb = 1.0 / betweenTime
self._serviceTime = serviceTime
self._numMinutes = numMinutes
# Simulation components.
self._passengerQ = ArrayQueue()
self._theAgents = Array(numAgents)
for i in range(numAgents):
self._theAgents[i] = TicketAgent(i + 1)
# Computed during the simulation.
self._totalWaitTime = 0
self._numPassengers = 0
def queue_to_stack(queue: ArrayQueue) -> ArrayStack:
"""
Return stack from queue (front of queue is peek of stack).
"""
copy_queue = ArrayQueue()
stack = ArrayStack()
for element in queue:
copy_queue.add(element)
reversed_queue = reverse_queue(copy_queue)
for element in reversed_queue:
stack.push(element)
return stack
def test_ArrayQueue_front(self):
queue = ArrayQueue()
for i in range(100):
queue.enqueue(i + 1)
for i in range(100):
assert_equal(i + 1, queue.front())
queue.dequeue()
def test():
Q = ArrayQueue()
Q.enqueue(5)
Q.enqueue(3)
print(Q.data)
print(Q.dequeue())
print(Q.is_empty())
print(Q.first())
print(Q.data)
def queue_to_stack(queue):
"""
converts queue to a stack
"""
queue_copy = ArrayQueue(queue)
stack = ArrayStack()
while True:
try:
element = queue_copy.pop()
stack.push(element)
except KeyError:
break
stack_reversed = ArrayStack()
while True:
try:
element = stack.pop()
stack_reversed.push(element)
except KeyError:
break
return stack_reversed
def queue_to_stack(queue):
"""
Converts the queue to a stack.
"""
stk_ar = ArrayStack()
q = ArrayQueue(queue)
el = []
while not q.isEmpty():
el.append(q.pop())
q1 = ArrayQueue(el[::-1])
while not q1.isEmpty():
stk_ar.push(q1.pop())
return stk_ar
def breadthfirst(self):
""" Breadth first iteration of all tree positions """
if not self.is_empty():
fringe = ArrayQueue()
fringe.enqueue(self.root())
while not fringe.is_empty():
p = fringe.dequeue()
yield p
for c in self.children(p):
fringe.enqueue(c)
def reverse_queue(queue: ArrayQueue) -> ArrayQueue:
"""
Return reversed queue. (Destructive! Clear queue).
"""
if len(queue) <= 1:
return queue
element = queue.pop()
reversed_queue = reverse_queue(queue)
reversed_queue.add(element)
return reversed_queue
def stack_to_queue(stack):
"""
converts stack to queue
"""
stack_copy = ArrayStack(stack)
queue = ArrayQueue()
while True:
try:
element = stack_copy.pop()
queue.add(element)
except KeyError:
break
queue_reversed = ArrayQueue()
while True:
try:
element = queue.pop()
queue_reversed.add(element)
except KeyError:
break
return queue_reversed
def breadth_first_search(self, v, reach, label):
aq = ArrayQueue()
reach[v] = label
aq.put(v)
while not aq.is_empty():
w = aq.remove()
p = self.adj_list[w].first_node
while p:
u = p.element.v
if not reach[u]:
aq.put(u)
reach[u] = label
p = p.next
print(reach)
def level_order(self, visit):
linked_binary_tree.visit = visit
aq = ArrayQueue()
curr_node = self.root
while curr_node:
visit(curr_node)
if curr_node.lc:
aq.put(curr_node.lc)
if curr_node.rc:
aq.put(curr_node.rc)
curr_node = aq.remove()
def main():
"""
tests module.
"""
queue = ArrayQueue()
for i in range(10):
queue.add(i)
stack = queue_to_stack(queue)
assert str(queue) == "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
assert str(stack) == "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]"
assert stack.pop() == 0
assert queue.pop() == 0
stack.add(11)
queue.add(11)
assert str(queue) == '[1, 2, 3, 4, 5, 6, 7, 8, 9, 11]'
assert str(stack) == "[9, 8, 7, 6, 5, 4, 3, 2, 1, 11]"
print("Success!")
def computeShortestPaths(self, srcIndex, use_heap):
self.source = srcIndex
nodes = self.network.getNodes()
self.distances = {}
self.previous_nodes = {}
for i in nodes:
self.distances[i.node_id] = math.inf
self.previous_nodes[i] = None
self.distances[self.source] = 0
t1 = time.time()
if not use_heap:
self.queue = ArrayQueue()
self.queue.make_queue(list(self.distances.keys()))
while self.queue.length > 0:
node_id = self.queue.deletemin(self.distances)
if node_id is not None:
for edge in nodes[node_id].neighbors:
# if current distance is greater than distance if we take another path
if self.distances[edge.dest.node_id] > (
self.distances[node_id] + edge.length):
self.distances[edge.dest.node_id] = self.distances[
node_id] + edge.length
self.previous_nodes[nodes[
edge.dest.node_id]] = nodes[node_id]
self.queue.decreasekey()
else:
self.queue = HeapQueue()
self.queue.make_queue(list(self.distances.keys()), self.distances)
while self.queue.length > 0:
node_id = self.queue.deletemin(self.distances)
if node_id is not None:
for edge in nodes[node_id].neighbors:
if self.distances[edge.dest.node_id] > (
self.distances[node_id] + edge.length):
self.distances[edge.dest.node_id] = self.distances[
node_id] + edge.length
self.previous_nodes[nodes[
edge.dest.node_id]] = nodes[node_id]
self.queue.decreasekey(edge.dest.node_id,
self.distances)
t2 = time.time()
return t2 - t1
def queue_to_stack(queue):
"""
Converts queue to stack.
"""
temp_queue = ArrayQueue()
temp_stack = ArrayStack() #elements are in reversed order
result_stack = ArrayStack()
while not queue.isEmpty():
elem = queue.pop()
temp_queue.add(elem)
temp_stack.push(elem)
while not temp_queue.isEmpty():
queue.add(temp_queue.pop())
while not temp_stack.isEmpty():
result_stack.push(temp_stack.pop()) #we reverse elements
return result_stack
from arrayqueue import ArrayQueue
from arraystack import ArrayStack
import random
def queue_to_stack(queue):
"""
Convert queue to stack
"""
stack1 = ArrayStack()
stack2 = ArrayStack()
while len(queue) != 0:
num = queue.pop()
stack1.push(num)
while len(stack1) != 0:
num = stack1.pop()
stack2.push(num)
return stack2
if __name__ == '__main__':
queue = ArrayQueue()
stack = ArrayStack()
for i in range(random.randint(5, 10)):
m = random.randint(0, 10)
queue.add(m)
stack.push(m)
print('Stack: ', stack)
print('Queue: ', queue_to_stack(queue))
def stack_to_queue(stack):
queue = ArrayQueue()
new_stack = copy.deepcopy(stack)
while not new_stack.isEmpty():
queue.add(new_stack.pop())
return queue
