def test_get_last_node(): """ Test getting the last node """ a, b, c = Item("a"), Item("b"), Item("c") tmp = LinkedList(None) tmp.add_to_list(a) assert tmp.get_last_node().item is a, "Expected last to be Item a" tmp.add_to_list(b) tmp.add_to_list(c) assert tmp.get_last_node().item is c, "Expected last to be Item c"
def _gen_tmp_list(): tmp = LinkedList(None) item_1 = Item("a") item_2 = Item("b") item_3 = Item("c") tmp.add_to_list(item_1) tmp.add_to_list(item_2) tmp.add_to_list(item_3) return tmp, [item_1, item_2, item_3]
def test_reverse_recur(): """ Test recursively reversing the linked list """ item_d = Item("d") tmp = LinkedList(None) tmp.add_to_list(item_d) tmp.reverse_recur() TestLinkedList._validate_list(tmp, [item_d]) tmp, [i1, i2, i3] = TestLinkedList._gen_tmp_list() tmp.add_to_list(item_d) tmp.reverse_recur() TestLinkedList._validate_list(tmp, [item_d, i3, i2, i1])
def test_add(): """ Test adding an item to the linked list """ tmp = LinkedList(None) tmp.add_to_list(Item("a")) assert len(tmp) == 1 tmp.add_to_list(Item("b")) tmp.add_to_list(Item("c")) assert len(tmp) == 3 titles_correct = ["a", "b", "c"] for idx, val in enumerate(tmp): assert titles_correct[idx] == val.item.title
def test_add_to_list(self): name = "Jose" matric = "1234" year = 2 node = Node(name, matric, year) linked_list = LinkedList() linked_list.add_to_list(node) self.assertEqual(linked_list.get_root(), node)
def test_merge(): """ Test mergint the linked list """ letters = ["a", "c", "e", "g"] letters2 = ["b", "d", "f", "h"] items = [] l1, l2 = LinkedList(None), LinkedList(None) for _, (i, i2) in enumerate(zip(letters, letters2)): l1.add_to_list(Item(i)) items.append(Item(i)) l2.add_to_list(Item(i2)) items.append(Item(i2)) l1.merge(l2) TestLinkedList._validate_list(l1, items)
def test_find_in_list(self): names = ("Jose", "1234", 2), ("Rolf", "2345", 3), ("Anna", "3456", 7) nodes = [Node(name, matric, year) for name, matric, year in names] linked_list = LinkedList() for node in nodes: linked_list.add_to_list(node) marker = linked_list.get_root() for i in range(len(nodes) - 1, -1, -1): self.assertEqual(linked_list.find_name(marker.get_name()), nodes[i]) marker = marker.get_next()
def test_sort(): """ Test sorting capability """ l = ListStore([3, 2, 7, 1]) after = sorted(l) assert after[0] == 1 ll = LinkedList(None) ll.add_to_list(Item("3")) ll.add_to_list(Item("2")) ll.add_to_list(Item("1")) store2 = ListStore(ll, sort_method=sorted, key_selector=lambda n: n.item.title) store2 = store2.sort() assert store2[0].item.title == "1" assert isinstance(store2, list)
class Stack: def __init__(self): self.__linked_list = LinkedList() def push(self, node): self.__linked_list.add_to_list(node) def pop(self): return self.__linked_list.remove_start_from_list() def print_details(self): self.__linked_list.print_list() def get_size(self): return self.__linked_list.get_size()
def test_sort(): """ Test sorting the linked list """ tmp, [i1, i2, i3] = TestLinkedList._gen_tmp_list() tmp.sort() TestLinkedList._validate_list(tmp, [i1, i2, i3]) i4 = Item("d") i5 = Item("e") i6 = Item("f") tmp.add_to_list(i5) tmp.add_to_list(i6) tmp.add_to_list(i4) tmp.sort() TestLinkedList._validate_list(tmp, [i1, i2, i3, i4, i5, i6]) tmp2 = LinkedList(None) tmp2.add_to_list(i1) tmp2.sort() TestLinkedList._validate_list(tmp2, [i1])
def test_delete_element_from_position(self): names = ("Jose", "1234", 2), ("Rolf", "2345", 3), \ ("Anna", "3456", 7), ("James", "2675", 5) nodes = [Node(name, matric, year) for name, matric, year in names] linked_list = LinkedList() for node in nodes: linked_list.add_to_list(node) linked_list.delete_element_from_position(linked_list.get_root(), 2) nodes_after_delete = [node for node in nodes if node.get_name() != "Rolf"] marker = linked_list.get_root () for i in range ( len (nodes_after_delete) - 1, -1, -1 ): self.assertEqual(linked_list.find_name(marker.get_name()), nodes_after_delete[i] ) marker = marker.get_next()
def test_delete_year_greater_than_3(self): names = ("Jose", "1234", 2), ("Rolf", "2345", 2), \ ("Anna", "3456", 2), ("James", "2675", 7) nodes = [Node ( name, matric, year ) for name, matric, year in names] linked_list = LinkedList () for node in nodes: linked_list.add_to_list ( node ) nodes_after_delete = [node for node in nodes if node.get_name () in ["Anna", "Rolf", "Jose"]] marker = linked_list.get_root () linked_list.delete_year_greater_than ( marker, 3 ) marker = linked_list.get_root () for i in range ( len ( nodes_after_delete ) - 1, -1, -1 ): self.assertEqual ( linked_list.find_name ( marker.get_name () ), nodes_after_delete[i] ) marker = marker.get_next ()
def test_insert_at_position3(self): names = ("Jose", "1234", 7), ("Rolf", "2345", 7), \ ("Anna", "3456", 7), ("James", "2675", 7) nodes = [Node ( name, matric, year ) for name, matric, year in names] linked_list = LinkedList () for node in nodes: linked_list.add_to_list(node) new_node = Node("Becky", "9898", 3) # Insert in the middle. nodes.insert(3, new_node) linked_list.insert_at_position(linked_list.get_root(), new_node, 1) marker = linked_list.get_root () for i in range(len(nodes) - 1, -1, -1): self.assertEqual(linked_list.find_name(marker.get_name()), nodes[i]) marker = marker.get_next ()
def test_compare_two_lists_by_name(self): names = ("Jose", "1234", 7), ("Rolf", "2345", 7), \ ("Anna", "3456", 7), ("James", "2675", 7) nodes = [Node ( name, matric, year ) for name, matric, year in names] linked_list1 = LinkedList() linked_list2 = LinkedList() for node in nodes: linked_list1.add_to_list(node) linked_list2.add_to_list(node) marker1 = linked_list1.get_root() marker2 = linked_list2.get_root() self.assertTrue(linked_list1.compare_two_lists_by_name(marker1, marker2)) linked_list2.reverse_linked_list(linked_list2.get_root()) marker2 = linked_list2.get_root () self.assertFalse(linked_list1.compare_two_lists_by_name(marker1, marker2))
def test_delete_year_greater_than_1(self): names = ("Jose", "1234", 7), ("Rolf", "2345", 7), \ ("Anna", "3456", 7), ("James", "2675", 7) nodes = [Node(name, matric, year) for name, matric, year in names] linked_list = LinkedList() for node in nodes: linked_list.add_to_list(node) nodes_after_delete = [node for node in nodes if node.get_name() in []] marker = linked_list.get_root() linked_list.delete_year_greater_than(marker, 3) # Make sure the head is updated, it could have been assigned to the node that meets # has year <= than . marker = linked_list.get_root() for i in range ( len (nodes_after_delete) - 1, -1, -1 ): self.assertEqual(linked_list.find_name(marker.get_name()), nodes_after_delete[i] ) marker = marker.get_next()
from Node_Stack import NodeS from stack import Stack from Node_BinaryTree import NodeB from binary_tree import BinaryTree print("---------------------- Linked List -------------------------------") name = "Mary" marks = 54 year = 2 student = Node(name, year, marks) linked_list = LinkedList() linked_list.add_to_list(student) linked_list.print_list() names = ("John", 2, 99), ("Ron", 3, 68), ("Anna", 7, 81) students = [Node(name, year, marks) for name, year, marks in names] new_linked_list = LinkedList() for student in students: new_linked_list.add_to_list(student) new_linked_list.print_list() new_linked_list.remove_from_list("Ron")