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
