def test_add_to_tail_implementation(self):
first_list = singly_linked_list.SinglyLinkedList()
first_list.addToHead(2)
first_list.addToHead(4)
first_list.addToHead(3)
second_list = singly_linked_list.SinglyLinkedList()
second_list.addToHead(5)
second_list.addToHead(6)
second_list.addToHead(4)
solution = singly_linked_list.Solution()
sumList = solution.addTwoNumbers(first_list, second_list)
self.assertEqual(sumList.get(0), 7)
self.assertEqual(sumList.get(1), 0)
self.assertEqual(sumList.get(2), 8)
def setUp(self):
"""for testing insert/delete of 0,1,2,3,4 in ascending order.
the test case here is specifically the scenario where 0,1,2,3,4
are added in that order.
"""
self.l = sll.SinglyLinkedList()
for i in range(5):
self.l.insert(i)
def test_Created_LinkedList_NodesNumber(self):
llist = linkedList.SinglyLinkedList()
self.assertEqual(llist.numberOfNodes(), 0)
llist.insertNode(32)
llist.insertNode(132)
llist.insertNode(4)
self.assertEqual(llist.numberOfNodes(), 3)
llist.deleteNodeAtIndex(0)
self.assertEqual(llist.numberOfNodes(), 2)
llist.deleteAllNodes()
self.assertEqual(llist.numberOfNodes(), 0)
def test_GetNode_From_Particular_Index(self):
llist = linkedList.SinglyLinkedList()
llist.insertNode(32)
llist.insertNode(132)
llist.insertNode(4)
self.assertEqual(llist.getNodeAtIndex(0).element, 32)
self.assertEqual(llist.getNodeAtIndex(1).element, 132)
self.assertEqual(llist.getNodeAtIndex(2).element, 4)
self.assertEqual(llist.getNodeAtIndex(2).next, None)
self.assertEqual(llist.getNodeAtIndex(4).element, None)
self.assertEqual(llist.getNodeAtIndex(4).next, None)
def test_DeleteNode_From_Particular_Index(self):
llist = linkedList.SinglyLinkedList()
llist.insertNode(32)
llist.insertNode(132)
llist.insertNode(4)
llist.insertNode(24)
llist.insertNode(1114)
llist.deleteNodeAtIndex(1)
self.assertEqual(llist.getAllNodes(), [32, 4, 24, 1114])
llist.deleteNodeAtIndex(0)
self.assertEqual(llist.getAllNodes(), [4, 24, 1114])
llist.deleteNodeAtIndex(2)
self.assertEqual(llist.getAllNodes(), [4, 24])
def test_Create_Add_Delete_Nodes(self):
llist = linkedList.SinglyLinkedList()
llist.insertNodeAtIndex(0, 1)
self.assertEqual(llist.getAllNodes(), [1])
llist.deleteAllNodes()
llist.insertNode(32)
llist.insertNode(132)
llist.insertNode(4)
self.assertEqual(llist.getAllNodes(), [32, 132, 4])
llist.insertNodeAtIndex(1, 11)
self.assertEqual(llist.getAllNodes(), [32, 11, 132, 4])
llist.insertNodeAtIndex(10, 99)
self.assertEqual(llist.getAllNodes(), [32, 11, 132, 4])
llist.insertNodeAtIndex(2, 10101)
self.assertEqual(llist.getAllNodes(), [32, 11, 10101, 132, 4])
llist.insertNodeAtIndex(0, 9009)
self.assertEqual(llist.getAllNodes(), [9009, 32, 11, 10101, 132, 4])
if fast is None or fast.nextt is None:
# there is no loop.
return head
slow = head
while slow.nextt != fast.nextt:
slow = slow.nextt
fast = fast.nextt
fast.nextt = None #removing the loop
return head
if __name__ == '__main__':
sll = ll.SinglyLinkedList(1)
# create linked list with loop
sll.head.nextt = ll.Node(2)
sll.head.nextt.nextt = ll.Node(3)
loop_start = ll.Node(4)
sll.head.nextt.nextt.nextt = loop_start
sll.head.nextt.nextt.nextt.nextt = ll.Node(5)
sll.head.nextt.nextt.nextt.nextt.nextt = ll.Node(6)
sll.head.nextt.nextt.nextt.nextt.nextt.nextt = ll.Node(7)
sll.head.nextt.nextt.nextt.nextt.nextt.nextt.nextt = loop_start
new_head = remove_loop(sll.head)
sll.print_list(new_head)
if(ptr1 == linkedList.head):
ptr1.next = None
temp = ptr2.next
ptr2.next = ptr1
ptr1 = ptr2
ptr2 = temp
linkedList.head = ptr1
def reverse(self):
if __name__=='__main__':
inputList = [9,2,3,4]
lList = sll.SinglyLinkedList()
for item in inputList:
lList.addElement(item)
lList.printLinkedList()
rev = ReverseLinkedList()
#rev.reverseIterative(lList)
#lList.printLinkedList()
rev.recursiveReverse(lList.head)
# - Traverse.
# - Push/Append/Insert nodes.
# - Remove by data/index.
# - Delete.
"""
#################################################
# ### Author: Samyuel Danyo
# ### Date: 31/05/2020
# ### Last Edit: 31/05/2020
##################################################
# Local Application/Library Specific Imports.
import singly_linked_list as sll
##################################################
# Test
##################################################
SLLIST = sll.SinglyLinkedList(sll.SLLNode(0))
for i in range(1, 6):
SLLIST.insert(i, i)
SLLIST.push(-1)
SLLIST.append(7)
SLLIST.insert_after(SLLIST.head.next, 100)
SLLIST.traverse()
print('=' * 30)
SLLIST.remove(100)
print(SLLIST)
print('=' * 30)
SLLIST.remove_node(3)
SLLIST.traverse()
print('=' * 30)
SLLIST.delete()
SLLIST.traverse()