def test_is_empty(self):
queue_a = QueueArray(1)
queue_l = QueueLinked(2)
self.assertTrue(queue_a.is_empty())
self.assertTrue(queue_l.is_empty())
queue_a.num_items = 1
queue_l.num_items += 2
self.assertFalse(queue_a.is_empty())
self.assertFalse(queue_l.is_empty())
def test_size(self):
queue_a = QueueArray(2)
queue_l = QueueLinked(2)
self.assertEqual(queue_a.size(), 0)
self.assertEqual(queue_l.size(), 0)
queue_a.num_items = 20
queue_l.num_items += 1
self.assertEqual(queue_a.size(), 20)
self.assertEqual(queue_l.size(), 1)
def test_dequeue(self):
queue_l = QueueLinked(1)
queue_l.rear, queue_l.front, queue_l.num_items = Node(10), Node(10), 1
self.assertEqual(queue_l.dequeue(), 10)
self.assertRaises(IndexError, queue_l.dequeue)
queue_a = QueueArray(1)
queue_a.front, queue_a.rear, queue_a.num_items = 0, 1, 1
queue_a.items = [10, None]
self.assertEqual(queue_a.dequeue(), 10)
self.assertRaises(IndexError, queue_a.dequeue)
def test_is_full(self):
queue_a = QueueArray(1)
queue_l = QueueLinked(2)
self.assertFalse(queue_a.is_full())
self.assertFalse(queue_l.is_full())
queue_a.num_items = 1
queue_l.num_items += 2
queue_a.rear += 1
self.assertTrue(queue_a.is_full())
self.assertTrue(queue_l.is_full())
def test_queue_linked(self):
q1 = QueueLinked(3)
q1.enqueue(0)
q1.enqueue(1)
self.assertEqual(q1.size(), 2)
q1.enqueue(2)
self.assertEqual(q1.is_full(), True)
def bicolor(self):
'''Returns True if the graph is bicolorable and False otherwise.
This method MUST use Breadth First Search logic!'''
verts = self.get_vertices()
for vert in verts:
if not self.get_vertex(vert).visited:
queue = QueueLinked(len(verts))
self.get_vertex(vert).visited = True
self.graph[vert].color = "black"
queue.enqueue(vert)
while not queue.is_empty():
source = queue.dequeue()
for adj_vert in self.graph[source].adjacent_to:
if not self.get_vertex(adj_vert).visited:
self.get_vertex(adj_vert).visited = True
if self.graph[source].color == "black":
self.graph[adj_vert].color = "red"
else:
self.graph[adj_vert].color = "black"
queue.enqueue(adj_vert)
else:
if self.graph[source].color == self.graph[
adj_vert].color:
self.is_bicolor = False
return self.is_bicolor
self.is_bicolor = True
return self.is_bicolor
def bfs(self, vert, component):
queue = QueueLinked(len(vert))
queue.enqueue()
while not queue.is_empty():
vertex = queue.dequeue()
lst = [vertex]
for adj_vert in vertex.adjacent_to:
return
def test_enqueue(self):
queue_l = QueueLinked(0)
self.assertRaises(IndexError, queue_l.enqueue, 10)
queue_l = QueueLinked(1)
queue_l.enqueue(10)
self.assertEqual(queue_l.rear, Node(10))
queue_a = QueueArray(1)
queue_a.enqueue(7)
self.assertEqual(queue_a.items, [7, None])
self.assertRaises(IndexError, queue_a.enqueue, 20)
def test_linked2(self):
stk_a = QueueLinked(4)
with self.assertRaises(IndexError):
stk_a.dequeue()
stk_a.enqueue(6)
stk_a.enqueue(7)
stk_a.enqueue(9)
self.assertEqual(stk_a.num_in_queue(), 3)
self.assertEqual(stk_a.dequeue(), 6)
self.assertEqual(stk_a.num_in_queue(), 2)
self.assertEqual(stk_a.dequeue(), 7)
self.assertEqual(stk_a.dequeue(), 9)
def test_linked(self):
stk_a = QueueLinked(4)
stk_a.enqueue(3)
self.assertEqual(stk_a.num_in_queue(), 1)
self.assertEqual(stk_a.dequeue(), 3)
self.assertTrue(stk_a.is_empty())
def test_QueueLinked(self):
queue = QueueLinked(2)
self.assertRaises(IndexError, queue.dequeue)
self.assertEqual(queue.is_empty(), True)
queue.enqueue(1)
self.assertEqual(queue.size(), 1)
queue.enqueue(2)
self.assertRaises(IndexError, queue.enqueue, 3)
self.assertEqual(queue.is_full(), True)
self.assertEqual(queue.dequeue(), 1)
self.assertEqual(queue.is_empty(), False)
self.assertEqual(queue.dequeue(), 2)
queue.enqueue(3)
self.assertEqual(queue.dequeue(), 3)