def test_get_extreme_values(a):
with pytest.raises(IndexError):
lnkd_lst = LinkedList()
lnkd_lst.get(a)
lnkd_lst.append('Hello')
lnkd_lst.append('World')
lnkd_lst.get(a)
def even_after_odd(llist):
"""
:param - head - head of linked list
return - updated list with all even elements are odd elements
"""
if llist.head.value is None:
return llist
even = LinkedList()
odd = LinkedList()
curr = llist.head
while curr is not None:
if curr.value % 2 == 0:
even.append(curr.value)
else:
odd.append(curr.value)
curr = curr.next
curr = odd.head
if curr is None:
return even
while curr.next is not None:
curr = curr.next
curr.next = even.head
return odd
def test_assign(lst):
lnkd_lst = LinkedList()
for i in lst:
lnkd_lst.append(i)
for i in range(len(lst)):
assert lnkd_lst.get(i).value == lnkd_lst.assign(50, i)
assert lnkd_lst.get(i).value == 50
def test_out(lst):
lnkd_lst = LinkedList()
test_str = ''
for i in lst:
lnkd_lst.append(i)
test_str += f'{i} '
assert lnkd_lst.out() == test_str
def sum_two_ssl(ssl1, ssl2):
p = ssl1.head
q = ssl2.head
final_list = LinkedList()
carry = 0
while p or q:
if not p:
i = 0
else:
i = p.get_data()
if not q:
j = 0
else:
j = q.get_data()
s = i + j + carry
if s >= 10:
carry = 1
remainder = s % 10
final_list.append(remainder)
else:
final_list.append(s)
if p:
p = p.get_next()
if q:
q = q.get_next()
return final_list
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]')
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 LinkedSumTest(unittest.TestCase):
def setUp(self):
self.x = LinkedList()
self.y = LinkedList()
self.reverse = LinkedList()
self.forward = LinkedList()
for i in (9, 9, 9):
self.x.append(i)
for i in (1, ):
self.y.append(i)
for i in (0, 0, 0, 1):
self.reverse.append(i)
for i in (1, 0, 0, 0):
self.forward.append(i)
#for i in (7, 1, 6):
#self.x.append(i)
#for i in (5, 9, 2):
#self.y.append(i)
#for i in (2, 1, 9):
#self.z.append(i)
def test_reverse_sum(self):
out = LinkedList()
out.first = reverse_sum(self.x.first, self.y.first, 0)
self.assertEqual(str(out), str(self.reverse))
def test_forward_sum(self):
out = LinkedList()
out.first = forward_sum(self.x.first, self.y.first)
self.assertEqual(str(out), str(self.forward))
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)
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 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("Reversing a list")
reverse(llist)
llist.print_list()
print("Reversing a list again using recursion")
reverse_rec(llist)
llist.print_list()
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 sum_two_lists(l1: LinkedList, l2: LinkedList) -> LinkedList:
p = l1.head
q = l2.head
sum_list = LinkedList()
carry = 0
while p or q:
i = p.data if p else 0
j = q.data if q else 0
# Calculate carry & remainder
s = i + j + carry
if s >= 10:
carry = 1
remainder = s % 10
sum_list.append(remainder)
else:
carry = 0
sum_list.append(s)
if p:
p = p.next
if q:
q = q.next
if carry:
sum_list.append(carry)
return sum_list
def populate_list(n=20, upper_bound=1000):
"""
this populates a linked list with values.
Parameter
--------
* n - the number of elements in our linked list
default: 20
* upper_bound - the upper bound of random integers
in our list.
Returns
-------
a LinkedList object from
singly_linked_list.py
"""
listing = LinkedList()
[listing.append(randint(0, 1000)) for _ in range(n)]
return listing
current_node = llist.head
new_list.head = Node(current_node.value)
while current_node:
current_node = current_node.next
if current_node:
new_node = Node(current_node.value)
new_node.next = new_list.head
new_list.head = new_node
return new_list
# Build the LinkedList with a python list:
llist = LinkedList()
python_list = [4, 2, 5, 1, -3, 0]
for value in python_list:
llist.append(value)
# old linked list and new linked list to compare:
print(list(llist), reverse(llist))
# Test your function:
# reverse the original python list with reverse built-in method:
python_list.reverse()
# reversed python list and reversed linked list:
print(python_list, reverse(llist))
print("Pass" if python_list == list(reverse(llist)) else "Fail")
def remove_duplicates(sll):
my_dict = {}
current = sll.head
prev = None
while current:
if current.get_data() in my_dict:
prev.next_node = current.next_node
current = None
else:
my_dict[current.get_data()] = 1
prev = current
current = prev.get_next()
return ssl
if __name__ == "__main__":
ssl = LinkedList()
ssl.append('a')
ssl.append('b')
ssl.append('b')
ssl.append('c')
ssl.append('a')
ssl.append('d')
ssl.append('a')
ssl.append('f')
x = remove_duplicates(ssl)
x.print_nodes()
class IsPalindromeTest(unittest.TestCase):
def setUp(self):
self.l = LinkedList()
for i in 'abcba':
self.l.append(i)
count = 0
current = ssl.head
while current:
if current.get_data() == data:
count += 1
current = current.get_next()
return count
def count_occurencces_recursive(ssl, node, data):
if not node:
return 0
if node.get_data() == data:
return 1 + count_occurencces_recursive(ssl, node.next_node, data)
else:
return count_occurencces_recursive(ssl, node.next_node, data)
if __name__ == "__main__":
ssl = LinkedList()
ssl.append(1)
ssl.append(2)
ssl.append(1)
ssl.append(4)
ssl.append(5)
ssl.append(1)
ssl.append(9)
ssl.append(1)
print(count_occurencces_recursive(ssl, ssl.head, 1))
j = 0
else:
j = q.get_data()
s = i + j + carry
if s >= 10:
carry = 1
remainder = s % 10
final_list.append(remainder)
else:
final_list.append(s)
if p:
p = p.get_next()
if q:
q = q.get_next()
return final_list
if __name__ == "__main__":
ss1 = LinkedList()
ss1.append(6)
ss1.append(5)
ss1.append(3)
ss2 = LinkedList()
ss2.append(4)
ss2.append(8)
result = sum_two_ssl(ss1, ss2)
result.print_nodes()
def test_pop_extreme_values(a):
with pytest.raises(IndexError):
lnkd_lst = LinkedList()
lnkd_lst.pop(a)
lnkd_lst.append('Hello')
lnkd_lst.append('World')
lnkd_lst.append('!')
lnkd_lst.append('Today')
lnkd_lst.append('I')
lnkd_lst.append('will')
lnkd_lst.append('conquer')
lnkd_lst.append('you')
lnkd_lst.append('!')
lnkd_lst.pop(a)
class IsPalindromeTest(unittest.TestCase):
def setUp(self):
self.l = LinkedList()
for i in 'abcba':
self.l.append(i)
def main():
# Create linked list :
# 10->20->30->40->50
list1 = LinkedList()
list1.append(10)
list1.append(20)
list1.append(30)
list1.append(40)
list1.append(50)
print("Printing List1:")
list1.print_list()
# Create linked list 2 :
# 5->15->18->35->60
list2 = LinkedList()
list2.append(5)
list2.append(15)
list2.append(18)
list2.append(35)
list2.append(60)
print("Prining List2:")
list2.print_list()
# Create linked list 3
list3 = LinkedList()
# Merging linked list 1 and linked list 2
# in linked list 3
list3.head = merge_ll(list1.get_head(), list2.get_head())
print(" Merged Linked List is : ", end="")
list3.print_list()
sum_list.append(remainder)
else:
carry = 0
sum_list.append(s)
if p:
p = p.next
if q:
q = q.next
if carry:
sum_list.append(carry)
return sum_list
l1 = LinkedList()
l1.append(2)
l1.append(1)
l1.append(5)
l1.print_list() # 5 -> 1 -> 2 ->
l2 = LinkedList()
l2.append(8)
l2.append(3)
l2.append(6)
l2.print_list() # 8 -> 3 -> 6 ->
sum_l = sum_two_lists(l1, l2)
sum_l.print_list() # 0 -> 5 -> 1 -> 1 ->
def test_append(lst):
lnkd_lst = LinkedList()
for i in lst:
lnkd_lst.append(i)
for i in range(len(lst) - 1, 0, -1):
assert lst[i] == lnkd_lst.get(i).value
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 test_get(a):
lnkd_lst = LinkedList()
lnkd_lst.append(a)
assert lnkd_lst.get(0).value == a
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 test_pop(a):
lnkd_lst = LinkedList()
for i in a:
lnkd_lst.append(i)
assert lnkd_lst.get(0).value == lnkd_lst.pop(0)
