def test_get_tail_item(self):
empty_linked_list = LinkedList()
empty_item = empty_linked_list.get_tail_item()
self.assertIsNone(empty_item)
linked_list = LinkedList("Bob")
item = linked_list.get_tail_item()
self.assertIsNotNone(item)
class Queue:
"""
An implementation for the Queue data structure
using a linked list.
"""
def __init__(self, item=None):
self.linked_list = LinkedList(item)
def enqueue(self, item):
"""Inserts an element in the back"""
self.linked_list.insert_at_tail(item)
def dequeue(self):
"""Removes and returns a node from the front"""
return self.linked_list.delete_head()
def peek(self):
"""Gets and returns the element from the front"""
return self.linked_list.head.item
def clear(self):
"""Clears the whole queue"""
self.linked_list.clear()
def get_size(self):
"""Returns the size of the queue"""
return self.linked_list.size
class DeleteNodeTest(unittest.TestCase):
def setUp(self):
self.l = LinkedList()
for i in range(3):
self.l.append(i)
self.node = self.l.first.next
def test_delete_node(self):
res = delete_node(self.node)
self.assertTrue(res)
self.assertEqual(str(self.l), 'Linked list: [0->2]')
def test_delete_tail(self):
self.linked_list.insert_at_tail("Bob")
self.linked_list.insert_at_tail("Jim")
self.linked_list.insert_at_tail("Ryan")
self.linked_list.insert_at_tail("Tim")
initial_size = self.linked_list.size
deleted_item = self.linked_list.delete_tail()
self.assertEqual(self.linked_list.size, initial_size - 1)
self.assertEqual(deleted_item, "Tim")
empty_linked_list = LinkedList()
empty_item = empty_linked_list.delete_tail()
self.assertIsNone(empty_item)
def test_insert_at_tail(self):
initial_size = self.linked_list.size
self.linked_list.insert_at_tail("Bob is your uncle")
self.assertEqual(self.linked_list.tail.item, "Bob is your uncle")
self.assertIsNotNone(self.linked_list.tail)
self.assertEqual(self.linked_list.size, initial_size + 1)
empty_linked_list = LinkedList()
empty_initial_size = empty_linked_list.size
empty_linked_list.insert_at_tail("Bob")
self.assertIsNotNone(empty_linked_list.head)
self.assertIsNotNone(empty_linked_list.tail)
self.assertEqual(empty_linked_list.size, empty_initial_size + 1)
class LoopOriginTest(unittest.TestCase):
def setUp(self):
self.l = LinkedList()
for i in 'ABCDE':
self.l.append(i)
def test_no_loop(self):
self.assertFalse(loop_origin(self.l.first))
def test_loop_origin(self):
origin = self.l.first.next.next
self.l.last.next = origin
self.assertEqual(loop_origin(self.l.first), origin)
class RemoveDupTest(unittest.TestCase):
def setUp(self):
self.l = LinkedList()
self.l.append(0)
self.l.append(1)
self.l.append(2)
self.old = self.l
def test_remove_dups_when_no_duplicates_exist(self):
remove_dups(self.l)
self.assertEqual(self.l, self.old)
def test_remove_dups_when_duplicates_exist(self):
self.l.append(1)
self.l.append(0)
remove_dups(self.l)
self.assertEqual(self.l, self.old)
def test_remove_dups_runner_when_no_duplicates_exist(self):
remove_dups_runner(self.l)
self.assertEqual(self.l, self.old)
def test_remove_dups_runner_when_duplicates_exist(self):
self.l.append(1)
self.l.append(0)
remove_dups_runner(self.l)
self.assertEqual(self.l, self.old)
def test_delete_head(self):
self.linked_list.insert_at_head("Bob")
initial_size = self.linked_list.size
deleted_item = self.linked_list.delete_head()
self.assertEqual(self.linked_list.size, initial_size - 1)
self.assertEqual(deleted_item, "Bob")
self.assertIsNone(self.linked_list.head)
self.assertIsNone(self.linked_list.tail)
another_deleted_item = self.linked_list.delete_head()
self.assertIsNone(another_deleted_item)
new_linked_list = LinkedList("Adrian")
new_linked_list.insert_at_head("Bob")
new_deleted_item = new_linked_list.delete_head()
self.assertEqual(new_deleted_item, "Bob")
self.assertEqual(new_linked_list.tail.item, "Adrian")
self.assertEqual(new_linked_list.head.item, "Adrian")
class FindKthTest(unittest.TestCase):
def setUp(self):
self.l = LinkedList()
for i in range(5):
self.l.append(i)
self.node = self.l.first
# naive approach
def test_first(self):
self.assertEqual(kth_to_last(self.l, 4), self.l.first)
def test_last(self):
self.assertEqual(kth_to_last(self.l, 0), self.l.last)
def test_middle(self):
self.assertEqual(kth_to_last(self.l, 3), self.l.first.next)
def test_out_of_range(self):
self.assertEqual(kth_to_last(self.l, 5), None)
# recursive
def test_first_recursive(self):
self.assertEqual(kth_to_last_recursive(self.node, 4), self.l.first)
def test_last_recursive(self):
self.assertEqual(kth_to_last_recursive(self.node, 0), self.l.last)
def test_middle_recursive(self):
self.assertEqual(kth_to_last_recursive(self.node, 3), self.l.first.next)
def test_out_of_range_recursive(self):
self.assertEqual(kth_to_last_recursive(self.node, 5), None)
# iterative
def test_first_iterative(self):
self.assertEqual(kth_to_last_iterative(self.node, 4), self.l.first)
def test_last_iterative(self):
self.assertEqual(kth_to_last_iterative(self.node, 0), self.l.last)
def test_middle_iterative(self):
self.assertEqual(kth_to_last_iterative(self.node, 3), self.l.first.next)
def test_out_of_range_iterative(self):
self.assertEqual(kth_to_last_iterative(self.node, 5), None)
def test_search_for_item(self):
linked_list = LinkedList("Bob")
linked_list.insert_at_tail("Kim")
linked_list.insert_at_tail("Jim")
linked_list.insert_at_tail("Max")
result = linked_list.search_for_item("Max")
self.assertEqual(result, (3, "Max"))
empty_result = linked_list.search_for_item("Adrian")
self.assertIsNone(empty_result)
class Stack:
"""
An implementation for the Stack data structure
using a linked list.
"""
def __init__(self, item=None):
self.linked_list = LinkedList(item)
def push(self, item):
"""Pushes an element onto the top of the stack"""
self.linked_list.insert_at_head(item)
def peek(self):
"""Gets and returns an element from the top of the stack"""
return self.linked_list.get_head_item()
def pop(self):
"""Removes and returns the element on top of the stack"""
return self.linked_list.delete_head()
def clear(self):
"""Removes all the elements form the stack"""
self.linked_list.clear()
def get_size(self):
"""Returns the size of the stack"""
return self.linked_list.size
def test_search_for_all_item(self):
linked_list = LinkedList("Bob")
linked_list.insert_at_tail("Kim")
linked_list.insert_at_tail("Bob")
linked_list.insert_at_tail("Bob")
result = linked_list.search_for_all_item("Bob")
self.assertEqual(len(result), 3)
def add_num_linkedlist(node1, node2):
if node1 is None and node2 is None:
return None
else:
carry = 0
newlist = LinkedList()
while node1 is not None or node2 is not None:
addition = 0
addition += carry
if node1 is not None:
addition += node1.data
node1 = node1.next
if node2 is not None:
addition += node2.data
node2 = node2.next
digit = addition % 10
if addition >= 10:
carry = 1
else:
carry = 0
newlist.insert(digit)
digit = 0
return newlist
import os
import sys
sys.path.append(f'{os.getcwd()}/singly_linked_list')
sys.path.append(f'{os.getcwd()}/binary_search_tree')
from singly_linked_list import LinkedList, Node
from binary_search_tree import BSTNode
my_list = LinkedList()
for i in range(20):
my_list.add_to_tail(i + 1)
# counter = 0
# current = my_list.head
# while current.next_node is not None:
# counter += 1
# current = current.next_node
# half = int(counter / 2)
# counter = 0
# current = my_list.head
# prev = None
# while counter != half:
# counter += 1
# prev = current
# current = current.next_node
# # current is our middle point
# next_node = current.next_node
# print(f"{current.value}")
class IsPalindromeTest(unittest.TestCase):
def setUp(self):
self.l = LinkedList()
for i in 'abcba':
self.l.append(i)
def __init__(self):
self.size = 0 #for array
#self.storage = []
self.storage = LinkedList()
def __init__(self):
self.size = 0
# self.storage = np.array([])
self.storage = LinkedList(None)
def setUp(self):
self.l = LinkedList()
for i in 'ABCDE':
self.l.append(i)
if prevX == None:
head = currY
else:
prevX.next = currY
# If y is head // make x as the new head
if prevY == None:
head = currX
else:
prevY.next = currX
# Swap next pointers
temp = currX.next
currX.next = currY.next
currY.next = temp
return head
if __name__ == '__main__':
l = LinkedList()
l.append_node("A")
l.append_node("B")
l.append_node("C")
l.append_node("D")
l.traverse()
l.head = swap_node(l.head, 'A', 'C')
l.traverse()
def __init__(self):
# Initialize this queue to the empty queue
self.size = 0
# Use the LinkedList class as storage
self.storage = LinkedList()
def __init__(self):
self.queue = LinkedList()
def __init__(self):
self.size: int = 0
self.storage: LinkedList = LinkedList()
def __init__(self):
self.size = 0 # using an array and linked list
# self.storage = [] # Using an array
self.storage = LinkedList() # using linked list
# return len(self.storage)
# def enqueue(self, value):
# self.size = self.size + 1
# self.storage.insert(0, value)
# def dequeue(self):
# if self.size == 0:
# return None
# else :
# self.size = self.size - 1
# return self.storage.pop()
# def state_props(self):
# print(self.size, self.storage)
linked = LinkedList()
class Queue:
def __init__(self):
self.size = 0
self.storage = linked
def __len__(self):
return self.size
def enqueue(self, value):
self.size = self.size + 1
# self.storage.insert(0, value)
self.storage.add_to_tail(value)
class TestSinglyLinkedList(unittest.TestCase):
def setUp(self):
self.linked_list = LinkedList()
def test_empty_init(self):
self.assertEqual(self.linked_list.size, 0)
self.assertIsNone(self.linked_list.head)
self.assertIsNone(self.linked_list.tail)
def test_init_with_item(self):
linked_list = LinkedList("Bob")
self.assertEqual(linked_list.size, 1)
self.assertIsNotNone(linked_list.head)
self.assertIsNotNone(linked_list.tail)
self.assertEqual(linked_list.head, linked_list.tail)
def test_insert_at_head(self):
initial_size = self.linked_list.size
self.linked_list.insert_at_head("Tom")
self.assertIsNotNone(self.linked_list.head)
self.assertEqual(self.linked_list.size, initial_size + 1)
self.assertEqual(self.linked_list.head.item, "Tom")
def test_insert_at_tail(self):
initial_size = self.linked_list.size
self.linked_list.insert_at_tail("Bob is your uncle")
self.assertEqual(self.linked_list.tail.item, "Bob is your uncle")
self.assertIsNotNone(self.linked_list.tail)
self.assertEqual(self.linked_list.size, initial_size + 1)
empty_linked_list = LinkedList()
empty_initial_size = empty_linked_list.size
empty_linked_list.insert_at_tail("Bob")
self.assertIsNotNone(empty_linked_list.head)
self.assertIsNotNone(empty_linked_list.tail)
self.assertEqual(empty_linked_list.size, empty_initial_size + 1)
def test_get_head_item_with_no_head(self):
item = self.linked_list.get_head_item()
self.assertIsNone(item)
def test_get_head_with_item(self):
linked_list = LinkedList("Bob")
item = linked_list.get_head_item()
self.assertIsNotNone(item)
self.assertEqual(item, "Bob")
def test_get_tail_item(self):
empty_linked_list = LinkedList()
empty_item = empty_linked_list.get_tail_item()
self.assertIsNone(empty_item)
linked_list = LinkedList("Bob")
item = linked_list.get_tail_item()
self.assertIsNotNone(item)
def test_get_item_at_index(self):
self.linked_list.insert_at_tail("Adrian")
self.linked_list.insert_at_tail("Bob")
self.linked_list.insert_at_tail("Chris")
item = self.linked_list.get_item_at_index(2)
self.assertEqual(item, "Chris")
with self.assertRaises(IndexError):
new_item = self.linked_list.get_item_at_index(5)
def test_search_for_item(self):
linked_list = LinkedList("Bob")
linked_list.insert_at_tail("Kim")
linked_list.insert_at_tail("Jim")
linked_list.insert_at_tail("Max")
result = linked_list.search_for_item("Max")
self.assertEqual(result, (3, "Max"))
empty_result = linked_list.search_for_item("Adrian")
self.assertIsNone(empty_result)
def test_search_for_all_item(self):
linked_list = LinkedList("Bob")
linked_list.insert_at_tail("Kim")
linked_list.insert_at_tail("Bob")
linked_list.insert_at_tail("Bob")
result = linked_list.search_for_all_item("Bob")
self.assertEqual(len(result), 3)
def test_delete_head(self):
self.linked_list.insert_at_head("Bob")
initial_size = self.linked_list.size
deleted_item = self.linked_list.delete_head()
self.assertEqual(self.linked_list.size, initial_size - 1)
self.assertEqual(deleted_item, "Bob")
self.assertIsNone(self.linked_list.head)
self.assertIsNone(self.linked_list.tail)
another_deleted_item = self.linked_list.delete_head()
self.assertIsNone(another_deleted_item)
new_linked_list = LinkedList("Adrian")
new_linked_list.insert_at_head("Bob")
new_deleted_item = new_linked_list.delete_head()
self.assertEqual(new_deleted_item, "Bob")
self.assertEqual(new_linked_list.tail.item, "Adrian")
self.assertEqual(new_linked_list.head.item, "Adrian")
def test_delete_tail(self):
self.linked_list.insert_at_tail("Bob")
self.linked_list.insert_at_tail("Jim")
self.linked_list.insert_at_tail("Ryan")
self.linked_list.insert_at_tail("Tim")
initial_size = self.linked_list.size
deleted_item = self.linked_list.delete_tail()
self.assertEqual(self.linked_list.size, initial_size - 1)
self.assertEqual(deleted_item, "Tim")
empty_linked_list = LinkedList()
empty_item = empty_linked_list.delete_tail()
self.assertIsNone(empty_item)
def test_delete_at_index(self):
self.linked_list.insert_at_tail("Adam")
self.linked_list.insert_at_tail("Bob")
self.linked_list.insert_at_tail("Chris")
self.linked_list.insert_at_tail("Dylan")
initial_size = self.linked_list.size
deleted_item = self.linked_list.delete_item_at_index(3)
self.assertEqual(self.linked_list.size, initial_size - 1)
self.assertEqual(deleted_item, "Dylan")
with self.assertRaises(IndexError):
self.linked_list.delete_item_at_index(5)
with self.assertRaises(ValueError):
self.linked_list.delete_item_at_index("Bla")
def test_clear(self):
self.linked_list.insert_at_tail("Adam")
self.linked_list.insert_at_tail("Bob")
self.linked_list.insert_at_tail("Chris")
self.linked_list.insert_at_tail("Dylan")
self.linked_list.insert_at_tail("Erin")
self.assertEqual(self.linked_list.size, 5)
self.linked_list.clear()
self.assertEqual(self.linked_list.size, 0)
def setUp(self):
self.linked_list = LinkedList()
def __init__(self, init_node=None):
if init_node:
self.size = 1
else:
self.size = 0
self.storage = LinkedList(init_node)
fast = dummy
for i in range(k):
# watch out for k > len of list
if fast is None:
return None
fast = fast.next
while fast.next:
slow = slow.next
fast = fast.next
return slow
ll = LinkedList()
ll.append_to_list(ListNode(1))
ll.append_to_list(ListNode(2))
ll.append_to_list(ListNode(3))
ll.append_to_list(ListNode(4))
ll.append_to_list(ListNode(5))
ll.append_to_list(ListNode(6))
get_kth_to_last(ll, 3)
ll.delete_node(6)
ll.delete_node(5)
ll.delete_node(4)
ll.delete_node(3)
ll.delete_node(2)
assert not get_kth_to_last(ll, 3)
while n:
nxt = n.next
if n.data < p:
n.next = head
head = n
else:
tail.next = n
tail = n
n = nxt
tail.next = None
return head
ll = LinkedList()
ll.append_to_list(ListNode(1))
ll.append_to_list(ListNode(4))
ll.append_to_list(ListNode(3))
ll.append_to_list(ListNode(10))
ll.append_to_list(ListNode(8))
ll.append_to_list(ListNode(63))
ll.append_to_list(ListNode(28))
ll.append_to_list(ListNode(13))
new_head = partition_linked_list(ll.head, 28)
result = []
n = new_head
while n:
result.append(n.data)
n = n.next
def __init__(self):
self.front = self.rear = None
self.size = 0
self.storage = LinkedList()
right_data = right_head.data
# If data on left is less than right, set current to left node
if left_data < right_data:
current.next_node = left_head
# Move left head to next node
left_head = left_head.next_node
# If data on left is greater than right, set current to right node
else:
current.next_node = right_head
# Move right head to next node
right_head = right_head.next_node
# Move current to next node
current = current.next_node
# Discard fake head and set first merge node as head
head = merged.head.next_node
merged.head = head
return merged
l = LinkedList()
l.add(12)
l.add(4)
l.add(45)
l.add(5)
l.add(34)
print(l)
sorted_list = merge_sort(l)
print(sorted_list)
def __init__(self, data):
LinkedList.__init__(self, data)
def __init__(self):
self.size = 0
self.items = LinkedList()
def __init__(self):
self.size = 0
self.storage = LinkedList()
temp = reverse_linked_list_recursion(head.next)
# Assume all nodes after the current node's next node are all
# reversed, now we need to reverse the next node and the
# current node.For example, when 3 is returned, temp will be 3,
# while head will be 2, and 2.next.next is now assigned to 2
# which means 3.next = 2, so the node is reversed.
head.next.next = head
# To avoid a list loop, we need to set head.next to None, in
# this case, 2.next is set to None for now.
head.next = None
# Return the last node or the first node in the reversed list.
# Here it's 3.
return temp
if __name__ == "__main__":
new_list = LinkedList([1,2,3,4,5,6])
print(f"Linked List: {new_list}")
new_head = reverse_linked_list(new_list.head)
reversed_list = LinkedList()
reversed_list.head = new_head
print(f"Linked List: {reversed_list}")
new_list = LinkedList([1,2,3,4,5,6])
print(f"Linked List: {new_list}")
reversed_head = reverse_linked_list_recursion(new_list.head)
new_reversed_list = LinkedList()
new_reversed_list.head = reversed_head
print(f"Linked List: {new_reversed_list}")
def setUp(self):
self.l = LinkedList()
self.l.append(0)
self.l.append(1)
self.l.append(2)
self.old = self.l
class LinkedListTests(unittest.TestCase):
def setUp(self):
self.list = LinkedList()
def test_add_to_tail(self):
self.list.add_to_tail(1)
self.assertEqual(self.list.tail.value, 1)
self.assertEqual(self.list.head.value, 1)
self.list.add_to_tail(2)
self.assertEqual(self.list.tail.value, 2)
self.assertEqual(self.list.head.value, 1)
def test_contains(self):
self.list.add_to_tail(1)
self.list.add_to_tail(2)
self.list.add_to_tail(5)
self.list.add_to_tail(10)
self.assertTrue(self.list.contains(10))
self.assertTrue(self.list.contains(2))
self.assertFalse(self.list.contains(1000))
def test_remove_head(self):
self.list.add_to_tail(10)
self.list.add_to_tail(20)
self.assertEqual(self.list.remove_head(), 10)
self.assertFalse(self.list.contains(10))
self.assertEqual(self.list.remove_head(), 20)
self.assertFalse(self.list.contains(20))
self.list.add_to_tail(10)
self.assertEqual(self.list.remove_head(), 10)
self.assertIsNone(self.list.head)
self.assertIsNone(self.list.tail)
self.assertIsNone(self.list.remove_head())
def test_get_max(self):
self.assertIsNone(self.list.get_max())
self.list.add_to_tail(100)
self.assertEqual(self.list.get_max(), 100)
self.list.add_to_tail(55)
self.assertEqual(self.list.get_max(), 100)
self.list.add_to_tail(101)
self.assertEqual(self.list.get_max(), 101)
def setUp(self):
self.l = LinkedList()
for i in 'abcba':
self.l.append(i)
def __init__(self, item=None):
self.linked_list = LinkedList(item)
def setUp(self):
self.l = LinkedList()
def __init__(self):
self.size = 0
# self.storage = ?
# self.storage = []
self.storage = LinkedList()
def test_get_head_with_item(self):
linked_list = LinkedList("Bob")
item = linked_list.get_head_item()
self.assertIsNotNone(item)
self.assertEqual(item, "Bob")
# If linkedlist has only one node
if head.next == None:
return head
# If linkedlist has more than one nodes
front = head.next.next
back = head
head = head.next
back.next = None
while front != None:
head.next = back
back = head
head = front
front = front.next
head.next = back
return head
if __name__ == '__main__':
l = LinkedList()
l.append_node("A")
l.append_node("B")
l.append_node("C")
l.traverse()
l.head = reverseLinkedList(l.head)
l.traverse()
class TestLinkedList(unittest.TestCase):
def setUp(self):
self.l = LinkedList()
def test_len(self):
self.assertEqual(len(self.l), 0)
def test_append_to_empty_list(self):
self.l.append(0)
self.assertEqual(self.l.first.value, 0)
self.assertEqual(self.l.last.value, 0)
self.assertEqual(len(self.l), 1)
def test_append_to_none_empty_list(self):
self.l.append(0)
self.l.append(1)
self.assertEqual(self.l.first.value, 0)
self.assertEqual(self.l.first.next.value, 1)
self.assertEqual(len(self.l), 2)
def test_str_of_empty_list(self):
self.assertEqual(str(self.l), "Linked list: []")
def test_str_of_one_node_list(self):
self.l.append(0)
self.assertEqual(str(self.l), "Linked list: [0]")
def test_str_of_multiple_nodes_list(self):
self.l.append(0)
self.l.append(1)
self.assertEqual(str(self.l), "Linked list: [0->1]")
def test_remove_from_empty_list(self):
x = self.l.remove(0)
self.assertEqual(x, None)
self.assertEqual(str(self.l), "Linked list: []")
def test_remove_from_one_node_list(self):
self.l.append(0)
x = self.l.remove(0)
self.assertEqual(x.value, 0)
self.assertEqual(str(self.l), "Linked list: []")
def test_remove_from_two_nodes_list(self):
self.l.append(0)
self.l.append(1)
x = self.l.remove(1)
self.assertEqual(x.value, 1)
self.assertEqual(str(self.l), "Linked list: [0]")
def test_remove_first_from_multiple_nodes_list(self):
for v in range(3):
self.l.append(v)
x = self.l.remove(0)
self.assertEqual(x.value, 0)
self.assertEqual(str(self.l), "Linked list: [1->2]")
def test_remove_middle_from_multiple_nodes_list(self):
for v in range(3):
self.l.append(v)
x = self.l.remove(1)
self.assertEqual(x.value, 1)
self.assertEqual(str(self.l), "Linked list: [0->2]")
def test_remove_last_from_multiple_nodes_list(self):
for v in range(2):
self.l.append(v)
self.l.append(2)
x = self.l.remove(2)
self.assertEqual(x.value, 2)
self.assertEqual(str(self.l), "Linked list: [0->1]")
def test_remove_none_existing_node(self):
for v in range(3):
self.l.append(v)
x = self.l.remove(4)
self.assertEqual(x, None)
self.assertEqual(str(self.l), "Linked list: [0->1->2]")
def test_reverse_empty_list(self):
self.l.reverse()
self.assertEqual(str(self.l), "Linked list: []")
def test_reverse_one_node_list(self):
self.l.append(0)
self.l.reverse()
self.assertEqual(str(self.l), "Linked list: [0]")
def test_reverse_multiple_nodes_list(self):
self.l.append(0)
self.l.append(1)
self.l.append(2)
self.l.reverse()
self.assertEqual(str(self.l), "Linked list: [2->1->0]")
def test_reverse_iterative(self):
self.l.append(0)
self.l.append(1)
self.l.append(2)
self.l.reverse()
self.assertEqual(str(self.l), "Linked list: [2->1->0]")
def __init__(self, size=0, storage=LinkedList()):
self.size = size
self.storage = storage
print(f"prev is: {prev.get_value()}")
else:
print("prev is None")
current = next_node # 2 -- 3, None
if current != None:
print(f"current is: {current.get_value()}")
else:
print("current is None")
ll.head, ll.tail = ll.tail, ll.head
# return ll
my_list = LinkedList()
my_list.add_to_tail(1)
my_list.add_to_tail(2)
my_list.add_to_tail(3)
my_current = my_list.head
while my_current is not None:
print(f"{my_current.get_value()}")
my_current = my_current.next_node
reverse_ll(my_list)
my_current = my_list.head
while my_current is not None:
import time
from singly_linked_list import LinkedList
n = 100000
# l = [i for i in range(n)]
l = []
ll = LinkedList()
start_time = time.time()
for i in range(n):
ll.add_to_tail(i)
end_time = time.time()
print(
f"Linked List add to list through range(n) took {end_time - start_time} seconds at n = {n}"
)
start_time = time.time()
for i in range(n):
l.append(i)
end_time = time.time()
print(
f"List (array) append to list through range(n) took {end_time - start_time} seconds at n = {n}"
)
start_time = time.time()
for i in range(n):
ll.remove_head()
end_time = time.time()
print(
f"Linked List remove from head through range(n) took {end_time - start_time} seconds at n = {n}"
class LinkedListTests(unittest.TestCase):
def setUp(self):
self.list = LinkedList()
def test_add_to_tail(self):
self.list.add_to_tail(1)
self.assertEqual(self.list.tail.value, 1)
self.assertEqual(self.list.head.value, 1)
self.list.add_to_tail(2)
self.assertEqual(self.list.tail.value, 2)
self.assertEqual(self.list.head.value, 1)
def test_remove_head(self):
self.list.add_to_tail(10)
self.list.add_to_tail(20)
self.assertEqual(self.list.remove_head(), 10)
self.assertEqual(self.list.remove_head(), 20)
self.list.add_to_tail(10)
self.assertEqual(self.list.remove_head(), 10)
self.assertIsNone(self.list.head)
self.assertIsNone(self.list.tail)
self.assertIsNone(self.list.remove_head())
def test_remove_tail(self):
self.list.add_to_tail(30)
self.list.add_to_tail(40)
self.assertEqual(self.list.remove_tail(), 40)
self.assertEqual(self.list.remove_tail(), 30)
self.list.add_to_tail(100)
self.assertEqual(self.list.remove_tail(), 100)
self.assertIsNone(self.list.head)
self.assertIsNone(self.list.tail)
self.assertIsNone(self.list.remove_tail())
def main():
llist = LinkedList()
llist.push(7)
llist.push(1)
llist.push(3)
llist.push(2)
llist.push(8)
llist.append(10)
llist.insert(llist.get_head().get_next(), 5)
llist.print_list()
print(find_middle(llist))
llist.delete_node(2)
llist.print_list()
print(find_middle(llist))
def setUp(self):
self.list = LinkedList()
def __init__(self):
self.__storage = LinkedList()
def setUp(self):
self.l = LinkedList()
for i in range(3):
self.l.append(i)
self.node = self.l.first.next
prevX.set_next(currY)
else:
llist.set_head(currY)
if prevY is not None:
prevY.set_next(currX)
else:
llist.set_head(currX)
# Second connect the next of current nodes
temp = currX.get_next()
currX.set_next(currY.get_next())
currY.set_next(temp)
llist = LinkedList()
llist.push(7)
llist.push(1)
llist.push(3)
llist.push(2)
llist.push(8)
print("Created Linked List:")
llist.print_list()
swap_nodes(llist, 2, 1)
llist.print_list()
swap_nodes(llist,8,1)
llist.print_list()
