def levelorder(self):
"""
-------------------------------------------------------
Copies the contents of the tree in levelorder order to a 2D list.
Use: values = bst.levelorder()
-------------------------------------------------------
Postconditions:
returns
values - a list containing the values of bst in levelorder.
(list of ?)
-------------------------------------------------------
"""
a = []
q = Queue()
node = self._root
if node is not None:
q.insert(node)
while not q.is_empty():
temp = q.remove()
a.append(temp._value)
if temp._left is not None:
q.insert(temp._left)
if temp._right is not None:
q.insert(temp._right)
return a
def test_queue01(self):
q = Queue(10)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
self.assertFalse(q.is_empty())
self.assertFalse(q.is_full())
self.assertEqual(q.size(), 3)
self.assertEqual(q.dequeue(), 1)
def test_is_full(self):
array = Queue(4)
array.enqueue(1)
self.assertFalse(array.is_full())
array.enqueue(2)
array.enqueue(3)
array.enqueue(4)
self.assertTrue(array.is_full())
def test_dq(self):
q = Queue(3)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.dequeue()
self.assertEqual(q.dequeue(), 2)
def test_none1(self):
"""Testing None"""
q = Queue(5)
q.enqueue(None)
q.enqueue(1)
self.assertFalse(q.is_empty())
self.assertFalse(q.is_full())
self.assertEqual(q.size(), 2)
def test_queue(self):
q = Queue(5)
self.assertEqual(q.is_empty(), True)
self.assertEqual(q.is_full(), False)
q.enqueue('thing')
self.assertEqual(q.dequeue(), 'thing')
self.assertEqual(q.size(), 0)
def queue_test(a):
"""
-------------------------------------------------------
Tests queue implementation.
Use: queue_test(a)
-------------------------------------------------------
Preconditions:
a - list of data (list of ?)
Postconditions:
the methods of Queue are tested for both empty and
non-empty queues using the data in a:
empty, insert, remove, peek
-------------------------------------------------------
"""
q = Queue()
# tests for the queue methods go here
print("***Is_empty test 1: {}".format(q.is_empty()))
print("***Array_to_queue ->")
array_to_queue(q, a)
print("***Is_empty test 2: {}".format(q.is_empty()))
print("***Tests remove(): {}".format(q.remove()))
print("***Peek test: {}".format(q.peek()))
print("***Insert '21' to the back of the queue: ")
q.insert(21)
for v in q:
print(v)
# print the results of the method calls and verify by hand
return
def level_order_list(
self
): # return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
q = Queue(25000) # Don't change this!
lst = []
q.enqueue(self.root)
while not q.is_empty():
temp = q.dequeue()
if temp is not None:
lst.append(temp.key)
q.enqueue(temp.left)
q.enqueue(temp.right)
return lst
def level_order_list(self): # (breadth first search)
# return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
if self.is_empty():
raise IndexError("levelorder not possible, empty tree")
key_list = []
q = Queue(25000) # Don't change this!
HEIGHT = self.tree_height_helper(self.root)
for desired_level in range(HEIGHT + 1):
q = self.level_order_list_helper(q, self.root, HEIGHT,
desired_level)
while q.size() != 0:
key_list.append(q.dequeue())
return key_list
def queue_test(a):
"""
-------------------------------------------------------
Tests queue implementation.
Use: queue_test(a)
-------------------------------------------------------
Preconditions:
a - list of data (list of ?)
Postconditions:
the methods of Queue are tested for both empty and
non-empty queues using the data in a:
empty, insert, remove, peek
-------------------------------------------------------
"""
q = Queue()
# tests for the queue methods go here
# print the results of the method calls and verify by hand
print("Empty queue: {}".format(q.is_empty()))
for i in a:
q.insert(i)
print("Items inserted into queue:")
for j in q:
print("{}".format(j))
print()
print("Remove: {}".format(q.remove()))
print()
if not q.is_empty():
print("Peek: {}".format(q.peek()))
else:
print("Queue is empty.")
return
def test_queue(self):
'''Trivial test to ensure method names and parameters are correct'''
q = Queue(5)
self.assertTrue(q.is_empty())
self.assertFalse(q.is_full())
q.enqueue('thing')
self.assertEqual(q.dequeue(), 'thing')
self.assertEqual(q.size(), 0)
def level_order_list(
self
): # return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
q = Queue(25000) # Don't change this!
q.enqueue(self.root)
l = []
while not q.is_empty():
node = q.dequeue()
l.append(node.key)
if node.left != None:
q.enqueue(node.left)
if node.right != None:
q.enqueue(node.right)
return l
def level_order_list(
self
): # return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
q = Queue(25000) # Don't change this!
l = []
q.enqueue(self.root)
if self.is_empty():
return l
while q.size() > 0:
x = q.dequeue()
l.append(x.key)
if x.left is not None:
q.enqueue(x.left)
if x.right is not None:
q.enqueue(x.right)
return l
def test_two(self):
r = Queue(5)
r.enqueue(1)
r.enqueue(2)
r.enqueue(3)
self.assertEqual(r.num_items, 3)
self.assertEqual(r.dequeue(), 1)
self.assertEqual(r.dequeue(), 2)
self.assertEqual(r.num_items, 1)
with self.assertRaises(IndexError):
while True:
r.enqueue(1)
self.assertEqual(r.num_items, r.capacity)
def test_is_empty(self): # DONE
"""Created and testing empty queue"""
my_q = Queue(5)
self.assertTrue(my_q.is_empty())
self.assertEqual(my_q.__repr__(), "Queue(5, [])")
"""Testing non-empty queue"""
my_q.enqueue(3)
self.assertFalse(my_q.is_empty())
def level_order_list(
self
): # return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
q = Queue(25000) # Don't change this!
nodelist = []
i = 0
returnlist = []
q.enqueue(self.root)
while not q.is_empty():
nodelist.append(q.dequeue())
if nodelist[i].left != None:
q.enqueue(nodelist[i].left)
if nodelist[i].right != None:
q.enqueue(nodelist[i].right)
i += 1
for j in range(len(nodelist)):
returnlist.append(nodelist[j].key)
return returnlist
def test_is_empty(self):
array = Queue(5)
self.assertTrue(array.is_empty())
array.enqueue(1)
self.assertFalse(array.is_empty())
def level_order_list(
self
): # return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
q = Queue(25000) # Don't change this!
if self.root == None:
return []
else:
q.enqueue(self.root)
x = []
while q.num_items > 0:
cur = q.dequeue()
x += [cur.key]
if cur.left != None:
q.enqueue(cur.left)
if cur.right != None:
q.enqueue(cur.right)
#self.root.lol(q)
#print(q.items[:5])
#x = []
#for i in range(q.num_items):
# x += [q.dequeue()]
return x
def queue_test(a):
"""
-------------------------------------------------------
Tests queue implementation.
Use: queue_test(a)
-------------------------------------------------------
Preconditions:
a - list of data (list of ?)
Postconditions:
the methods of Queue are tested for both empty and
non-empty queues using the data in a:
is_empty, insert, remove, peek
-------------------------------------------------------
"""
from queue_array import Queue
q = Queue()
q.insert(a[1])
q.peek()
print(q.peek())
print(q.remove())
return
def queue_test(a):
"""
-------------------------------------------------------
Tests queue implementation.
Use: queue_test(a)
-------------------------------------------------------
Preconditions:
a - list of data (list of ?)
Postconditions:
the methods of Queue are tested for both empty and
non-empty queues using the data in a:
empty, insert, remove, peek
-------------------------------------------------------
"""
q = Queue()
for i in a:
q.insert(i)
print("Is the queue empty: {}".format(q.is_empty()))
print("Removed: {}".format(q.remove()))
print("Peek {}".format(q.peek()))
return
import random
from Patron import Patron
from Server import Server
from queue_array import Queue
print("Welcome to the Dew-Drop Inn. Party Hearty - but Responsibly!")
print()
print("Please enter the following parameters:")
run_time = int(input(" Run time (minutes): "))
number_servers = int(input(" Number of servers: "))
patrons_per_min = int(input(" Maximum number of patrons arriving per minute: "))
min_service_time = int(input(" Minimum service time (minutes): "))
max_service_time = int(input(" Maximum service time (minutes): "))
chance_of_rejection = float(input(" Chance of a patron being rejected: "))
q = Queue()
servers = []
patron_count = 0
average_service_time = 0
past_queue_size = len(q)
total_wait_time = 0
total_wait_time_left_over = 0
idle_time = 0
rejection = 0
for x in range(number_servers+1):
s = Server(x+1, None)
servers.append(s)
for i in range(run_time):
if past_queue_size < len(q):
past_queue_size = len(q)
print("Time {}".format(i))
def test_queue(self):
'''Trivial test to ensure method names and parameters are correct'''
q = Queue(5)
q.is_empty()
q.is_full()
q.enqueue('thing')
self.assertEqual(q.peek(), 'thing')
q.dequeue()
with self.assertRaises(IndexError):
q.peek()
q.size()
def test_queue2(self):
q = Queue(3)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.dequeue()
q.dequeue()
q.dequeue()
q.enqueue(4)
self.assertFalse(q.is_full())
def test_empty_queue(self):
q = Queue(0)
with self.assertRaises(IndexError):
q.enqueue(1)
with self.assertRaises(IndexError):
q.dequeue()
def setUp(self):
self.q = Queue()
def test_init(self):
self.assertEqual(self.queue.get_size(), 0)
new_queue = Queue("Bob")
self.assertEqual(new_queue.get_size(), 1)
class TestStack(unittest.TestCase):
def setUp(self):
self.queue = Queue()
def test_init(self):
self.assertEqual(self.queue.get_size(), 0)
new_queue = Queue("Bob")
self.assertEqual(new_queue.get_size(), 1)
def test_enqueue(self):
self.queue.enqueue("Bob")
self.assertEqual(self.queue.get_size(), 1)
def test_dequeue(self):
self.queue.enqueue("Bob")
dequeued_item = self.queue.dequeue()
self.assertEqual(dequeued_item, "Bob")
another_dequeued_item = self.queue.dequeue()
self.assertIsNone(another_dequeued_item)
def test_peek(self):
self.queue.enqueue("Bob")
self.queue.enqueue("Bill")
self.queue.enqueue("Boris")
peeked_item = self.queue.peek()
self.assertEqual(peeked_item, "Bob")
def test_clear(self):
for i in range(0, 100):
self.queue.enqueue("Bob")
self.assertEqual(self.queue.get_size(), 100)
self.queue.clear()
self.assertEqual(self.queue.get_size(), 0)
def test_get_size(self):
self.assertEqual(self.queue.get_size(), 0)
def test_queue(self):
'''Trivial test to ensure method names and parameters are correct'''
q = Queue(5)
self.assertTrue(q.is_empty())
self.assertFalse(q.is_full())
q.enqueue('thing')
self.assertEqual(q.dequeue(), 'thing')
self.assertEqual(q.size(), 0)
for i in range(5):
q.enqueue(i)
self.assertTrue(q.is_full())
self.assertFalse(q.is_empty())
with self.assertRaises(IndexError):
q.enqueue(1)
self.assertEqual(q.size(), 5)
with self.assertRaises(IndexError):
e = Queue(1)
e.dequeue()
from queue_array import Queue
q = Queue()
print q.dequeue() # None
q.enqueue('to')
q.enqueue('be')
q.enqueue('or')
q.enqueue('not')
q.enqueue('to')
print q.dequeue() # to
q.enqueue('be')
print q.dequeue() # be
print q.dequeue() # or
q.enqueue('that')
print q.dequeue() # not
print q.dequeue() # to
print q.dequeue() # be
q.enqueue('is')
def setUp(self):
self.queue = Queue()
def level_order_list(
self
): # return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
q = Queue(25000) # Don't change this!
pass
""" ---------------------------------------------------- q5.py Tests identical function. ---------------------------------------------------- Author: Qadeer Assan ID: 160257370 Email: [email protected] _updated_="2018-02-01" ---------------------------------------------------- """ from queue_array import Queue from asgn04 import identical q1 = Queue() q2 = Queue() q1.insert(0) q1.insert(2) q2.insert(0) q2.insert(2) b = identical(q1, q2) print("q1==q2: ", b) q3 = Queue() q4 = Queue() q3.insert(0) q3.insert(2) q4.insert(1) q4.insert(3) c = identical(q3, q4) print("q3==q4: ", c)
def test_queue(self):
'''Trivial test to ensure method names and parameters are correct'''
q = Queue(5)
self.assertTrue(q.is_empty())
self.assertFalse(q.is_full())
q.enqueue(3)
q.enqueue(5)
self.assertEqual(q.size(), 2)
q.enqueue(8)
q.enqueue(9)
q.enqueue(7)
with self.assertRaises(IndexError):
q.enqueue(8)
self.assertFalse(q.is_empty())
self.assertTrue(q.is_full())
q.dequeue()
self.assertEqual(q.dequeue(), 5)
self.assertEqual(q.size(), 3)
q.dequeue()
q.dequeue()
self.assertEqual(q.dequeue(), 7)
self.assertEqual(q.size(), 0)
with self.assertRaises(IndexError):
q.dequeue()
q.enqueue(3)
q.enqueue(5)
q.enqueue(7)
q.enqueue(4)
q.enqueue(8)
self.assertEqual(q.dequeue(), 3)
q.enqueue(2)
q.dequeue()
self.assertEqual(q.dequeue(), 7)
""" ---------------------------------------------------- ---------------------------------------------------- Author: Qadeer Assan ID: 160257370 Email: [email protected] _updated_="2018-02-01" ---------------------------------------------------- """ from queue_array import Queue q1 = Queue() q2 = Queue() q1.insert(0) q1.insert(2) q2.insert(0) q2.insert(2) b = q1.identical(q2) print("q1==q2: ", b) q3 = Queue() q4 = Queue() q3.insert(0) q3.insert(2) q4.insert(1) q4.insert(3) c = q3.identical(q4) print("q3==q4: ", c)
def line_up2(total_time, max_arrival_time, max_service_time, max_queue_size, number_servers):
# initialize counters, queue, bool
q = Queue()
patron_id = 1
arriving = 0
serving = 0
max_queue = 0
patrons_served = 0
total_wait_time = 0
turned_away = 0
being_served = []
# loop through user inputted total_time
for time in range(0, total_time + 1):
if time != 0:
print("Time = {}".format(time))
# determine when patrons join the queue
if arriving == time:
if len(q) == max_queue_size:
turned_away += 1
if time != 0 and len(q) < max_queue_size:
print(" Action: patron {} joins the queue.".format(patron_id))
patron = Patron(patron_id, copy.deepcopy(time))
q.insert(patron)
patron_id += 1
if len(q) > max_queue:
max_queue = len(q)
arriving += random.randint(1, max_arrival_time)
# determine when servers finish with patrons
popped_index = []
if len(being_served) != 0:
for i in range(len(being_served)):
if being_served[i].end_service_time == time:
print(" Action: patron {} finishes being served.".format(being_served[i].patron))
popped_index.append(i)
patrons_served += 1
if len(popped_index) != 0:
for i in range(len(popped_index), 0, -1):
being_served.pop(popped_index[i - 1])
# determine when servers accept new patrons
if len(being_served) < number_servers and q.is_empty() == False:
print(" Action: patron {} starts the service.".format(q.peek().name))
serving = time
serving += random.randint(1, max_service_time)
server = Server(max_service_time, q.peek().name, serving)
being_served.append(server)
total_wait_time += time - q.peek().arrival_time
q.remove()
# display results
print("Club is now closed")
print("End simulation")
print()
print("The maximum queue size (longest line of patrons): {}".format(max_queue))
print("The number of patrons turned away: {}".format(turned_away))
print("The number of patrons served: {}".format(patrons_served))
print("The number of patrons left in the queue: {}".format(len(q)))
print("The average time between arrivals (in minutes): {:.1f}".format(total_time / patron_id))
# if statement to avoid dividing by 0 if no patrons are served
if patrons_served != 0:
print(
"The average wait time in the queue per patron (in minutes): {:.1f}".format(
total_wait_time / patrons_served
)
)
else:
print("The average wait time in the queue per patron (in minutes): None")
return
