class animatedLinkedList: def __init__(self): window = Tk() window.title("Linked List") self.lst = Queue() self.canvas = Canvas(window, width = 400, height = 200) self.canvas.pack() frame = Frame(window) frame.pack() Label(frame, text = "Element").pack(side = LEFT) self.v1 = StringVar() self.v1.set("") Entry(frame, textvariable = self.v1).pack(side = LEFT) self.lstx = 10 self.lsty = 80 self.bx = 10 self.by = 100 Button(frame, text = "Insert (enqueue)", command = self.insert).pack(side = LEFT) Button(frame, text = "Delete (dequeue)", command = self.delete).pack(side = LEFT) window.mainloop() def insert(self): if self.v1.get() == "": tkinter.messagebox.showerror("Error", "No input in element") else: self.lst.enqueue(int(self.v1.get())) self.update() def delete(self): self.lst.dequeue() self.update() def update(self): self.canvas.delete(ALL) x = self.lst.getSize() self.lstx = 10 self.lsty = 80 self.n = self.lst.__str__() self.n = self.n.split(", ") if len(self.n) > 1: a = self.n[0] self.n[0] = a.replace("[", "") b = self.n[len(self.n) - 1] self.n[len(self.n) - 1] = b.replace("]", "") elif len(self.n) == 1: a = self.n[0] a = a.replace("[", "") a = a.replace("]", "") self.n[0] = a print(self.n) for i in range(x): self.canvas.create_rectangle(self.lstx, self.lsty, self.lstx + 30, self.lsty + 20) self.canvas.create_text(self.lstx + 15, self.lsty + 10, text = self.n[i]) self.lstx += 30
class TestQueue(unittest.TestCase): def setUp(self): self.queue = Queue() def test_0(self): print("{} Can create Queue object".format(inspect.stack()[0][3])) self.assertTrue(type(self.queue) is Queue) def test_1(self): print("{} Newly created queues should be empty".format(inspect.stack()[0][3])) self.assertTrue(self.queue.isEmpty()) def test_2(self): print("{} After one enqueue, queue size should be one".format(inspect.stack()[0][3])) self.queue.enqueue(1) self.assertEqual(self.queue.getSize(), 1) def test_3(self): print("{} After one enqueue and one dequeue, should be empty".format(inspect.stack()[0][3])) self.queue.enqueue(1) self.queue.dequeue() self.assertEqual(self.queue.getSize(),0) def test_4(self): print("(S) {} When enqueued passed limit, queue overflows".format(inspect.stack()[0][3])) def test_5(self): print("{} When dequeued passed limit, queue underflows".format(inspect.stack()[0][3])) with self.assertRaises(Queue.Underflow): self.queue.dequeue() def test_6(self): print("{} When two values are enqueued then one is dequeued, size is one".format(inspect.stack()[0][3])) self.queue.enqueue(1) self.queue.enqueue(2) self.queue.dequeue() self.assertEqual(self.queue.getSize(),1) def test_7(self): print("{} When 1 is enqueued 1 is dequeued".format(inspect.stack()[0][3])) self.queue.enqueue(1) self.assertEqual(self.queue.dequeue(),1) def test_8(self): print("{} When 1 and 2 are enqueued 1 and 2 are dequeued".format(inspect.stack()[0][3])) self.queue.enqueue(1) self.queue.enqueue(2) self.assertEqual(self.queue.dequeue(),1) self.assertEqual(self.queue.dequeue(),2) def test_9(self): print("(S) {} When creating queue with negative size, should throw IllegalCapacity".format(inspect.stack()[0][3])) def test_10(self): print("(S) {} When Creating queue with zero capacity, any enqueue should overflow".format(inspect.stack()[0][3])) def test_11(self): print("{} When 1 is enqueued, 1 is on top".format(inspect.stack()[0][3])) self.queue.enqueue(1) self.assertEqual(self.queue.top(),1) def test_12(self): print("{} When queue is empty, top throws empty".format(inspect.stack()[0][3])) with self.assertRaises(Queue.Empty): self.queue.top() def test_13(self): print("(S) {} With zero capacity queue, top throws empty".format(inspect.stack()[0][3])) def test_14(self): print("{} Given queue with 1 2 enqueued, find 1 and 2".format(inspect.stack()[0][3])) self.queue.enqueue(1) self.queue.enqueue(2) self.assertEqual(self.queue.find(1),0) self.assertEqual(self.queue.find(2),1) def test_15(self): print("{} Given a queue with no 2, find(2) returns null".format(inspect.stack()[0][3])) self.assertEqual(self.queue.find(2),None)
def calcNodeVisibilityDegree(self, nodeID): """ This function is used to calculate visibility degree of a specified node. @param nodeId: A node identifier. @return: It returns a visibility degree of specified node. """ # Visibility degree of specified node... visibilityDegree = 0 # 'successorsNodeQueue' is used to store successors nodes... successorsNodeQueue = Queue() # 'supportList' is used to unmark all visited nodes during operation... supportList = list() # Number intermediate nodes... intermediateNodes = 0 # Add node for which the visibility is calculated... # ---------------------------------------------------- # successorsNodeQueue.enqueue(nodeID) while(not successorsNodeQueue.isEmpty()): # Get current queue size.. # ---------------------------------------------------- #. successorsNodeQueueSize = successorsNodeQueue.getSize() # Get all successors of nodes stored in 'successorsNodeQueue'... # ---------------------------------------------------- # for _ in range(successorsNodeQueueSize): # Get all successors of element at the head of the queue... # ---------------------------------------------------- # successors = self.getSuccessors(successorsNodeQueue.dequeue()) for elem in successors: if(not self._nodeSet[elem]._isVisited): # Visit found nodes... # ---------------------------------------------------- # # Mark as visited... self._nodeSet[elem]._isVisited = True # Checking visibility... if (intermediateNodes <= self._nodeSet[elem]._value): visibilityDegree += 1 # Update data structure... successorsNodeQueue.enqueue(elem) supportList.append(elem) # Update number of intermediate nodes... intermediateNodes += 1 # Remark all visited node as not-visited... for nodeID in supportList: self._nodeSet[nodeID]._isVisited = False # Return visibility degree... return visibilityDegree