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)
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
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)