def test_rec_merge(): # 测试link1为空链表 link1 = LinkedList() link2 = LinkedList() link2.append(1) assert rec_merge(link1.root, link2.root) == link2.root # 测试link2为空链表 link1 = LinkedList() link1.append(1) link2 = LinkedList() assert rec_merge(link1.root, link2.root) == link1.root # 测试两个空链表 link1 = LinkedList() link2 = LinkedList() assert rec_merge(link1.root, link2.root) == link2.root # 测试两个完整的链表 link1 = LinkedList() link2 = LinkedList() link1.append(1) link1.append(3) link2.append(2) link2.append(4) link2.append(4) link2.append(5) print(rec_merge(link1.root, link2.root).value) print(rec_merge(link1.root, link2.root).value)
def test_insert_after(): initialList = LinkedList() initialList.append(5) initialList.append(6) initialList.append(7) initialList.insertAfter(8, 7) assert str(initialList) == '5 ->6 ->7 ->8'
def test_merge(): # 测试link1为空链表 link1 = LinkedList() link2 = LinkedList() link2.append(1) assert merge(link1.root, link2.root) == link2.root # 测试link2为空链表 link1 = LinkedList() link1.append(1) link2 = LinkedList() assert merge(link1.root, link2.root) == link1.root # 测试两个空链表 link1 = LinkedList() link2 = LinkedList() assert merge(link1.root, link2.root) == link2.root # 测试两个完整的链表 link1 = LinkedList() link2 = LinkedList() link1.append(1) link1.append(3) link2.append(2) link2.append(4) link2.append(4) link2.append(5) assert list(merge(link1.root, link2.root)) == [1, 2, 3, 4, 4, 5]
def test_insert_before(): initialList = LinkedList() initialList.append(6) initialList.append(7) initialList.append(8) initialList.insertBefore(5, 6) assert str(initialList) == '5 ->6 ->7 ->8'
def test_append(): initialList = LinkedList() initialList.append(5) initialList.append(6) initialList.append(7) initialList.append(8) assert str(initialList) == '5 ->6 ->7 ->8'
def test_remove_dups_no_buffer_t(self): ll_with_dups = LinkedList() ll_with_dups.append(2) ll_with_dups.append(2) ll_with_dups.append(2) ll_with_dups.remove_dups_no_buffer() self.assertEqual(ll_with_dups.to_s(), '2')
def testLength(self): ll = LinkedList() self.assertEqual(ll.length(), 0) ll.append(1) ll.append(2) ll.append(3) self.assertEqual(ll.length(), 3)
def main(): ll = LinkedList() print("Initial size: ", len(ll)) ll.push(24) print("New size: ", len(ll)) print("List content: ", ll) print("Pushing more") ll.push(6) ll.push(783) print("List content: ", ll) print("popping...") ll.pop() print("List content: ", ll) print("Does list contain 24?") if ll.contains(24): print("Yes") else: print("No") print("Deleting 24") ll.delete(24) print("List content: ", ll) print("Pushing another onto end.") ll.append(365) print("List content: ", ll)
def testReturnLastNode(self): ll = LinkedList() self.assertEqual(ll.return_last_node(), None) ll.append(1) self.assertEqual(ll.return_last_node().data, 1) ll.append(2) self.assertEqual(ll.return_last_node().data, 2)
class Node: """hash list node""" def __init__(self, data): self.connections = LinkedList() self.data = data def connect(self, node): """ returns next node""" if node: self.connections.append(node) def disconnect(self, node): """ det next node """ if node: self.connections.remove(node) def get(self): """ returns node date """ return self.data def __str__(self): connections = '' for node in self.connections: connections += f'[{node.data}] ' return f'{self.data}: {connections}'
def test_2(self): """test append method""" n1 = Node('A') link = LinkedList() link.append(n1) self.assertEqual(link._head._value, 'A') self.assertEqual(len(link), 1)
class Queue: """Linked List implementation of the Queue ADT""" def __init__(self): self.list = LinkedList() def __len__(self): return len(self.list) def push(self, data): node = Node(data) self.list.append(node) # if this was prepend, we'd have a stack def pop(self): if self.is_empty(): raise StopIteration("Attempting to pop from empty queue") node = self.list.head.data self.list.remove_head() return node def is_empty(self): return self.list.head is None def peek(self): return self.list.head.data def __str__(self): return str([data for _, data in self.list.traverse()])
def test_4(self): """test that pop off only item in list that head becomes None""" n1 = Node('A') link = LinkedList() link.append(n1) link.pop() self.assertEqual(link._head, None)
def test_get(self): l = LinkedList() self.assertIsNone(l.get(1)) l.append(1) self.assertEqual(1, l.get(0)) l.append(2) self.assertEqual(2, l.get(1))
def sum_lists(ll1,ll2): value1=value2=0 pointer=ll1.head while pointer: value1=value1*10+pointer.data pointer=pointer.next pointer=ll2.head while pointer: value2=value2*10+pointer.data pointer=pointer.next result=value1+value2 print value1,value2,result ll_sum=LinkedList() divider=10**(len(str(result))-1) while result: digit=result//divider ll_sum.append(digit) result=result%divider divider/=10 #ll_sum.append(result) return ll_sum
def test_print(self): test_list = LinkedList() test_list.append(1) test_list.append(2) test_list.append(3) test_list.append(2) self.assertEqual(test_list.to_s(), '1 2 3 2')
class Graph: """Adjacency list implementation of directed graph Linked list represents graph of nodes. Edges are represented as linked list of nodes indexes, connected to node. """ def __init__(self): self.nodes = LinkedList() def __repr__(self): return "Graph" + repr(self.nodes) def insert(self, *links: int): """Add node with links """ edges = LinkedList() for link in links: edges.append(link) self.nodes.append(edges) def lookup(self, node_index: int): """Return node using value""" return self.nodes.lookup(node_index) def delete(self, node_index: int): """Delete node and its references to other nodes""" # Delete references from other nodes for node in self.nodes: for index, link in enumerate(node.data): if link.data == node_index: node.data.delete(index) # Delete node and its references self.nodes.delete(node_index)
def test_is_empty(self): l = LinkedList() self.assertEqual(l.is_empty(), True) l.append("I don't wanna close my eyes...") self.assertEqual(l.is_empty(), False)
def test_append(): ll = LinkedList() ll.insert('violet') ll.insert('indigo') ll.insert('blue') ll.append('green') assert ll.head.next.next.next.value =='green'
def zipLists(list1, list2): current_one = list1.head current_two = list2.head if current_one == None: return print(list2) if current_two == None: return print(list1) new_list = LinkedList() while current_one or current_two: if current_one: if new_list.head == None: new_list.insert(current_one.value) else: new_list.append(current_one.value) if current_two: if new_list.head == None: new_list.insert(current_two.value) else: new_list.append(current_two.value) if current_one and current_one.next: current_one = current_one.next else: current_one = False if current_two and current_two.next: current_two = current_two.next else: current_two = False return new_list
def test_str(): linked_list = LinkedList() assert linked_list.__str__() == 'LinkedList []' linked_list.append('Alice') linked_list.append('Bob') assert linked_list.__str__() == """LinkedList [
def ll_merge(ll_one, ll_two): result_list = LinkedList() try: ll_one_current = ll_one.head ll_two_current = ll_two.head while ll_one_current is not None or ll_two_current is not None: # ll_one_next = ll_one_current._next # ll_two_next = ll_two_current._next if ll_one_current is not None: result_list.append(ll_one_current) ll_one_current = ll_one_current._next if ll_two_current is not None: result_list.append(ll_two_current) ll_two_current = ll_two_current._next result_list_current = result_list.head while result_list_current is not None: print(result_list_current) result_list_current = result_list_current._next # return result_list # ll_one_current._next, ll_two_current._next = ll_two_next, ll_one_next # ll_one_current = ll_one_next # ll_two.head = ll_two_current except None: 'Not valid input'
def sum_two_list(self, llist): p = self.head q = self.head sum_list = LinkedList() carry = 0 while p or q: if not p: i = 0 else: i = p.data if not q: j = 0 else: j = q.data 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 sum_list.print_llist()
def test_append(self): """test_append: Test appending to a linked list """ node1 = Node('test') lst = LinkedList() lst.append(node1) self.assertTrue(len(lst) == 1)
def test_last_of_two_nodes(self): """ In a two-node list, the second node is the last node. """ ll = LinkedList() appendee = LinkedList(fake_value()) ll.append(appendee) self.assertEqual(appendee, ll.last())
def test_append_to_empty_list_sets_prev_of_sentinel_to_new_node(self): """ Appending to an empty list sets the sentinel's `prev` to the new node. """ ll = LinkedList() appendee = LinkedList(fake_value()) ll.append(appendee) self.assertEqual(appendee, ll.prev)
def test_list_with_two_nodes_is_not_empty(self): """ A list with two nodes is not empty. """ ll = LinkedList() appendee = LinkedList(fake_value()) ll.append(appendee) self.assertFalse(ll.is_empty())
def test_first_of_two_nodes_is_not_last(self): """ In a two-node list, the first node is not last. """ ll = LinkedList() appendee = LinkedList(fake_value()) ll.append(appendee) self.assertFalse(ll.is_last())
def test_second_of_two_nodes_is_last(self): """ In a two-node list, the second node is last. """ ll = LinkedList() appendee = LinkedList(fake_value()) ll.append(appendee) self.assertTrue(appendee.is_last())
def test_append_to_empty_list_sets_next_of_new_node_to_sentinel(self): """ Appending to an empty list sets the new node's `next` to the sentinel. """ ll = LinkedList() appendee = LinkedList(fake_value()) ll.append(appendee) self.assertEqual(ll, appendee.next)
def test_AppendLinkedList(self): linked_list = LinkedList() num_of_elements = 5 for i in range(num_of_elements): linked_list.append(i) self.assertEquals(linked_list.size, num_of_elements) for i in range(num_of_elements): self.assertEquals(i, linked_list[i].data)
def set(self, key, value): index = hash(key) % self.size if self.slots[index] == None: bucket = LinkedList() bucket.append([key, value]) self.slots[index] = bucket else: self.slots[index].append((key, value))
def test_linked_list_append(self): linked_list = LinkedList() linked_list.append(25) self.assertIsNotNone(linked_list) self.assertTrue(linked_list.__len__()==1) linked_list.append("Riccardo") self.assertTrue(linked_list.__len__()==2) self.assertTrue(linked_list.head.item==25) self.assertTrue(linked_list.head.next.item =="Riccardo") self.assertFalse(linked_list.head.next.item == "25")
def test_linked_list_search(self): linked_list = LinkedList() linked_list.append(25) pos = linked_list.search(25) self.assertIsNotNone(linked_list) self.assertTrue(pos == 0) linked_list.append("Riccardo") pos = linked_list.search("Riccardo") self.assertEqual(pos,1) linked_list.insert_head("Prova") pos = linked_list.search("Prova") self.assertTrue(pos == 0)
def test_LinkedList_append(self): l1 = LinkedList() l1.append(0) # ensure Node(0) added to list Node0 = l1.head self.assertEqual(Node0.val, 0) self.assertIsNone(Node0.link) # ensure Node(1) appended to back of list l1.append(1) Node0 = l1.head self.assertEqual(Node0.val, 0) self.assertIsNotNone(Node0.link) # ensure Node(0) is next in list Node1 = Node0.link self.assertEqual(Node1.val, 1) self.assertIsNone(Node1.link) # ensure adding 'None' adds something sz1 = l1.size() l1.append(None) self.assertEqual(sz1+1, l1.size()) # ensure adding recursively adds nothing sz1 = l1.size() l1.append(l1) self.assertEqual(sz1, l1.size())
def test_append(self): my_list = LinkedList() my_list.append(1) self.assertEqual(my_list.start.elem, 1) self.assertEqual(my_list.start.next, None) self.assertEqual(my_list, LinkedList([1])) my_list.append(2) self.assertEqual(my_list.start.elem, 1) self.assertEqual(my_list.start.next, Node(2)) self.assertEqual(my_list.start.next.elem, 2) self.assertEqual(my_list.start.next.next, None) self.assertEqual(my_list.count(), 2)
class AssociativeArray: def __init__(self): self.items = LinkedList() def __unicode__(self): s = '' for key, value in self.items: s += repr(key) + ': ' + repr(value) + ', ' return '{' + s + '}' __repr__ = __unicode__ def put(self, key, value): for i, kv in enumerate(self.items): if kv[0] == key: l1 = self.items.take(i) l2 = self.items.drop(i + 1) self.items = l1.concat(l2) break self.items = self.items.append((key, value)) def get(self, key): for k, v in self.items: if k == key: return v
def test_ReverseLinkedList(self): linked_list = LinkedList() reversed_man_list = LinkedList() num_of_elements = 5 for i in range(num_of_elements): linked_list.append(i) self.assertEquals(linked_list.size, num_of_elements) for i in range(num_of_elements-1, -1, -1): reversed_man_list.append(i) linked_list.reverse() for index, item in enumerate(linked_list): self.assertEquals(item.data, reversed_man_list[index].data)
def test_clear() -> None: node_1_data = {"id": 1} node_2_data = {"id": 2} node_3_data = {"id": 3} node_4_data = {"id": 4} linked_list = LinkedList() linked_list.append(node_4_data) linked_list.append(node_3_data) linked_list.append(node_2_data) linked_list.append(node_1_data) linked_list.clear() assert linked_list.head is None assert linked_list.tail is None
def test_removing_elements() -> None: node_1_data = {"id": 1} node_2_data = {"id": 2} node_3_data = {"id": 3} node_4_data = {"id": 4} linked_list = LinkedList() linked_list.append(node_1_data) linked_list.append(node_2_data) linked_list.append(node_3_data) linked_list.append(node_4_data) node_2 = linked_list.find(target_key="id", target_value=node_2_data["id"]) linked_list.remove(node_2) assert linked_list.head is not None assert linked_list.head.data == node_1_data assert linked_list.head.next_node is not None assert linked_list.head.next_node.data == node_3_data assert linked_list.tail is not None assert linked_list.tail.data == node_4_data assert linked_list.tail.previous_node is not None assert linked_list.tail.previous_node.data == node_3_data node_1 = linked_list.find(target_key="id", target_value=node_1_data["id"]) linked_list.remove(node_1) assert linked_list.head is not None assert linked_list.head.data == node_3_data assert linked_list.head.next_node is not None assert linked_list.head.next_node.data == node_4_data assert linked_list.tail is not None assert linked_list.tail.data == node_4_data assert linked_list.tail.previous_node is not None assert linked_list.tail.previous_node.data == node_3_data node_4 = linked_list.find(target_key="id", target_value=node_4_data["id"]) linked_list.remove(node_4) assert linked_list.head is not None assert linked_list.head.data == node_3_data assert linked_list.head.next_node is None assert linked_list.tail is not None assert linked_list.tail.data == node_3_data assert linked_list.tail.previous_node is None node_3 = linked_list.find(target_key="id", target_value=node_3_data["id"]) linked_list.remove(node_3) assert linked_list.head is None assert linked_list.tail is None
def main(): linked_list = LinkedList() values = [5, 2, 7, 7, 33, 1, 6, 0, 4, 3] for num in values: linked_list.append(num) print(str(linked_list)) # find 1st to last print(find_k_elem(linked_list.head, 1).value) # find 2nd to last print(find_k_elem(linked_list.head, 2).value) # find 6th to last print(find_k_elem(linked_list.head, 6).value) # find 33 to last elem print(find_k_elem(linked_list.head, 33))
class LinkedListTest(unittest.TestCase): def setUp(self): self.ll = LinkedList() for i in range(1, 6): self.ll.append(i) def test_creation(self): self.assertEqual(5, len(self.ll)) def test_pop_value(self): self.assertEqual(1, self.ll.pop()) def test_pop_length(self): self.ll.pop() self.assertEqual(4, len(self.ll)) def test_push_value(self): self.ll.push(0) self.assertEqual(0, self.ll.get_head().value) def test_push_length(self): self.ll.push(0) self.assertEqual(6, len(self.ll)) def test_remove_length(self): node = self.ll.get_head().next.next self.ll.remove(node) self.assertEqual(4, len(self.ll)) def test_distinct(self): self.assertEqual([1, 2, 3, 4, 5], self.ll.distinct()) def test_distinct_with_duplicate(self): self.ll.append(1) self.assertEqual([1, 2, 3, 4, 5], self.ll.distinct()) def test_cycle_false(self): self.assertEqual(False, self.ll.has_cycle()) def test_cycle_true(self): last_node = self.ll.get_tail() last_node.next = self.ll.get_head() self.assertEqual(True, self.ll.has_cycle())
def test_insert_after() -> None: node_1_data = {"id": 1} node_2_data = {"id": 2} node_3_data = {"id": 3} node_4_data = {"id": 4} linked_list = LinkedList() linked_list.append(node_1_data) linked_list.append(node_2_data) node_1 = linked_list.find(target_key="id", target_value=node_1_data["id"]) # Normal insert scenario linked_list.insert_after(data=node_3_data, node=node_1) assert linked_list.head.data == node_1_data second_node = linked_list.head.next_node assert second_node is not None assert second_node.data == node_3_data third_node = second_node.next_node assert third_node is not None assert third_node.data == node_2_data assert third_node.next_node is None assert linked_list.tail.data == node_2_data node_2 = linked_list.find(target_key="id", target_value=node_2_data["id"]) # Insert at tail scenario linked_list.insert_after(data=node_4_data, node=node_2) assert linked_list.head.data == node_1_data second_node = linked_list.head.next_node assert second_node is not None assert second_node.data == node_3_data third_node = second_node.next_node assert third_node is not None assert third_node.data == node_2_data fourth_node = third_node.next_node assert fourth_node is not None assert fourth_node.data == node_4_data assert fourth_node.next_node is None assert linked_list.tail.data == node_4_data
def test_reversing_list() -> None: node_1_data = {"id": 1} node_2_data = {"id": 2} node_3_data = {"id": 3} node_4_data = {"id": 4} linked_list = LinkedList() linked_list.append(node_1_data) linked_list.append(node_2_data) linked_list.append(node_3_data) linked_list.append(node_4_data) linked_list.reverse() assert linked_list.head is not None assert linked_list.head.data == node_4_data assert linked_list.head.previous_node is None second_node = linked_list.head.next_node assert second_node is not None assert second_node.data == node_3_data third_node = second_node.next_node assert third_node is not None assert third_node.data == node_2_data fourth_node = third_node.next_node assert fourth_node is not None assert fourth_node.data == node_1_data assert fourth_node.next_node is None assert linked_list.tail is not None assert fourth_node.data == linked_list.tail.data # Now go back to check previous links third_node = fourth_node.previous_node assert third_node is not None assert third_node.data == node_2_data second_node = third_node.previous_node assert second_node is not None assert second_node.data == node_3_data first_node = second_node.previous_node assert first_node is not None assert first_node.data == node_4_data
def add(list_a, list_b): list_c = LinkedList([0]) node_a = list_a.head node_b = list_b.head node_c = list_c.head carry = 0 while node_a or node_b: a = node_a.value if node_a else 0 b = node_b.value if node_b else 0 result = a + b + carry carry, result = divmod(result, 10) node_c.value = result if carry: list_c.append(carry) node_a = node_a.next_node if node_a else None node_b = node_b.next_node if node_b else None node_c = node_c.next_node return list_c
def test_finding_elements() -> None: node_1_data = {"id": 1} node_2_data = {"id": 2} node_3_data = {"id": 3} other_data = {"id": 4} linked_list = LinkedList() linked_list.append(node_1_data) linked_list.append(node_2_data) linked_list.append(node_3_data) node = linked_list.find(target_key="id", target_value=node_1_data["id"]) assert node is not None assert node.data == node_1_data node = linked_list.find(target_key="id", target_value=node_2_data["id"]) assert node is not None assert node.data == node_2_data node = linked_list.find(target_key="id", target_value=node_3_data["id"]) assert node is not None assert node.data == node_3_data assert linked_list.find(target_key="id", target_value=other_data["id"]) is None assert linked_list.find(target_key="inexistant_key", target_value="an_irrelevant_value") is None
class Queue: def __init__(self): self.items = LinkedList() @property def is_empty(self): """O(1)""" return self.items.is_empty def enqueue(self, x): """O(n) --> should be O(1)""" self.items = self.items.append(x) def dequeue(self): """O(1)""" if self.is_empty: raise UnderflowException else: x = self.items.head self.items = self.items.drop(1) return x
def add_lists(l1, l2): if (l1 is None) or (l2 is None) or ((l1.head is None) and (l2.head is None)): return None ll = LinkedList([]) h = 0 n1 = l1.head n2 = l2.head if n1 is not None: h += n1.data if n2 is not None: h += n2.data digit = h % 10 remember = (h - (h % 10)) / 10 ll.append(digit) while (n1 is not None) or (n2 is not None): h = 0 if n1 is not None: n1 = n1.next if n2 is not None: n2 = n2.next if n1 is not None: h += n1.data if n2 is not None: h += n2.data h += remember digit = h % 10 remember = (h - (h % 10)) / 10 if (n1 is not None) or (n2 is not None): ll.append(digit) else: if digit > 0: ll.append(digit) if remember > 0: ll.append(remember) return ll
def test_AddLinkedList(self): first = LinkedList() other = LinkedList() compare_list = LinkedList() num_of_elements = 5 for i in range(num_of_elements): first.append(i) other.append(i) compare_list.append(i+i) self.assertEquals(first.size, num_of_elements) self.assertEquals(other.size, num_of_elements) res = first + other for index, item in enumerate(res): self.assertEquals(item.data, compare_list[index].data)
def test_AddDecimalLinkedList_SameLength_NoCarry(self): first = LinkedList() second = LinkedList() compare_list = LinkedList() num_of_elements = 4 for i in range(num_of_elements): first.append(i) second.append(i) compare_list.append(i+i) print(first) print(second) print(compare_list) res = first.add_as_decimal(second) for index, item in enumerate(res): self.assertEquals(item.data, compare_list[index].data)
def test_appending_elements() -> None: node_1_data = {"id": 1} node_2_data = {"id": 2} node_3_data = {"id": 3} linked_list = LinkedList() linked_list.append(data=node_1_data) assert linked_list.head is not None assert linked_list.head.data == node_1_data assert linked_list.tail is not None assert linked_list.tail.data == node_1_data linked_list.append(data=node_2_data) assert linked_list.head.data == node_1_data assert linked_list.head.next_node is not None assert linked_list.head.next_node.data == node_2_data assert linked_list.head.previous_node is None assert linked_list.tail.data == node_2_data assert linked_list.tail.next_node is None assert linked_list.tail.previous_node is not None assert linked_list.tail.previous_node.data == node_1_data linked_list.append(data=node_3_data) assert linked_list.head.data == node_1_data assert linked_list.head.next_node is not None assert linked_list.head.next_node.data == node_2_data assert linked_list.head.previous_node is None assert linked_list.tail.data == node_3_data assert linked_list.tail.next_node is None assert linked_list.tail.previous_node is not None assert linked_list.tail.previous_node.data == node_2_data middle_node = linked_list.head.next_node assert middle_node.data == node_2_data assert middle_node.next_node is not None assert middle_node.next_node.data is not None assert middle_node.next_node.data == node_3_data assert middle_node.previous_node is not None assert middle_node.previous_node.data is not None assert middle_node.previous_node.data == node_1_data
from linked_list import LinkedList from pprint import pprint list = LinkedList() list.append(3) list.append('b') list.append('v') list.append(list) list.append(0) print(list.__unicode__())
class TestLinkedList(unittest.TestCase): def setUp(self): self.list = LinkedList() def tearDown(self): self.list = None def test_append(self): self.list.append("Mr. Green") self.assertTrue(self.list.head.data == "Mr. Green") self.assertTrue(self.list.head.next_node is None) def test_append_two(self): self.list.append("Mr. Green") self.list.append("Miss Scarlet") self.assertTrue(self.list.head.data == "Miss Scarlet") new_head = self.list.head.next_node self.assertTrue(new_head.data == "Mr. Green") def test_next_node(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") self.assertTrue(self.list.head.data == "Mr. Boddy") new_head = self.list.head.next_node self.assertTrue(new_head.data == "Mrs. Peacock") last = new_head.next_node self.assertTrue(last.data == "Prof. Plum") def test_len(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") length = self.list.__len__() self.assertTrue(length == 3) def test_len_zero(self): length = self.list.__len__() self.assertTrue(length == 0) def test_len_one(self): self.list.append("Prof. Plum") length = self.list.__len__() self.assertTrue(length == 1) def test_succeed_getitem(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") result = self.list.__getitem__(0) self.assertTrue(result == "Mr. Boddy") result = self.list.__getitem__(1) self.assertTrue(result == "Mrs. Peacock") result = self.list.__getitem__(2) self.assertTrue(result == "Prof. Plum") def test_fail_getitem(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") with self.assertRaises(IndexError): self.list.__getitem__(2) @unittest.skip('Extra Challenge: pop method.') def test_pop(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") old_head = self.list.pop() self.assertTrue(old_head.data == "Mr. Boddy") new_head = self.list.head self.assertTrue(new_head.data == "Mrs. Peacock") new_length = len(self.list) self.assertTrue(new_length == 2) @unittest.skip('Extra Challenge: pop method.') def test_pop_empty_list(self): with self.assertRaises(IndexError): self.list.pop() @unittest.skip('Extra Challenge: __delitem__ method.') def test_delete(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") # Delete the list head self.list.__delitem__(0) self.assertTrue(self.list.head.data == "Mrs. Peacock") # Delete the list tail self.list.__delitem__(1) self.assertTrue(self.list.head.next_node is None) new_length = len(self.list) self.assertTrue(new_length == 1) @unittest.skip('Extra Challenge: __delitem__ method.') def test_delete_value_not_in_list(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") with self.assertRaises(IndexError): self.list.__delitem__(3) @unittest.skip('Extra Challenge: __delitem__ method.') def test_delete_empty_list(self): with self.assertRaises(IndexError): self.list.__delitem__(1) @unittest.skip('Extra Challenge: __delitem__ method.') def test_delete_next_reassignment(self): self.list.append("Prof. Plum") self.list.append("Mrs. White") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") self.list.__delitem__(1) self.list.__delitem__(1) self.assertTrue(self.list.head.next_node.data == "Prof. Plum")
def test_flip() -> None: node_1_data = {"id": 1} node_2_data = {"id": 2} node_3_data = {"id": 3} node_4_data = {"id": 4} node_5_data = {"id": 5} linked_list = LinkedList() linked_list.append(node_1_data) linked_list.append(node_2_data) linked_list.append(node_3_data) linked_list.append(node_4_data) linked_list.append(node_5_data) # non-consecutive nodes: # 1 2 3 4 5 -> 1 4 3 2 5 linked_list.flip(linked_list.head.next_node, linked_list.tail.previous_node, "id") first_node = linked_list.head assert first_node.data == node_1_data assert first_node.previous_node is None assert first_node.next_node.data == node_4_data second_node = linked_list.head.next_node assert second_node is not None assert second_node.data == node_4_data assert second_node.previous_node.data == node_1_data assert second_node.next_node.data == node_3_data third_node = second_node.next_node assert third_node is not None assert third_node.data == node_3_data assert third_node.previous_node.data == node_4_data assert third_node.next_node.data == node_2_data fourth_node = third_node.next_node assert fourth_node is not None assert fourth_node.data == node_2_data assert fourth_node.previous_node.data == node_3_data assert fourth_node.next_node.data == node_5_data fifth_node = fourth_node.next_node assert fifth_node is not None assert fifth_node.data == node_5_data assert fifth_node.previous_node.data == node_2_data assert fifth_node.next_node is None assert linked_list.tail.data == node_5_data # consecutive nodes: # 1 4 3 2 5 -> 1 4 2 3 5 linked_list.flip(linked_list.tail.previous_node.previous_node, linked_list.tail.previous_node, "id") first_node = linked_list.head assert first_node.data == node_1_data assert first_node.previous_node is None assert first_node.next_node.data == node_4_data second_node = linked_list.head.next_node assert second_node is not None assert second_node.data == node_4_data assert second_node.previous_node.data == node_1_data assert second_node.next_node.data == node_2_data third_node = second_node.next_node assert third_node is not None assert third_node.data == node_2_data assert third_node.previous_node.data == node_4_data assert third_node.next_node.data == node_3_data fourth_node = third_node.next_node assert fourth_node is not None assert fourth_node.data == node_3_data assert fourth_node.previous_node.data == node_2_data assert fourth_node.next_node.data == node_5_data fifth_node = fourth_node.next_node assert fifth_node is not None assert fifth_node.data == node_5_data assert fifth_node.previous_node.data == node_3_data assert fifth_node.next_node is None assert linked_list.tail.data == node_5_data # A = head B = tail # 1 4 3 2 5 -> 5 4 2 3 1 linked_list.flip(linked_list.head, linked_list.tail, "id") first_node = linked_list.head assert first_node.data == node_5_data assert first_node.previous_node is None assert first_node.next_node.data == node_4_data second_node = linked_list.head.next_node assert second_node is not None assert second_node.data == node_4_data assert second_node.previous_node.data == node_5_data assert second_node.next_node.data == node_2_data third_node = second_node.next_node assert third_node is not None assert third_node.data == node_2_data assert third_node.previous_node.data == node_4_data assert third_node.next_node.data == node_3_data fourth_node = third_node.next_node assert fourth_node is not None assert fourth_node.data == node_3_data assert fourth_node.previous_node.data == node_2_data assert fourth_node.next_node.data == node_1_data fifth_node = fourth_node.next_node assert fifth_node is not None assert fifth_node.data == node_1_data assert fifth_node.previous_node.data == node_3_data assert fifth_node.next_node is None assert linked_list.tail.data == node_1_data
def test_sorting() -> None: def node_comparison_function(node): return int(node.data["id"]) if node else 0 node_1_data = {"id": 1} node_2_data = {"id": 2} node_3_data = {"id": 3} node_4_data = {"id": 4} linked_list = LinkedList() linked_list.append(node_4_data) linked_list.append(node_3_data) linked_list.append(node_2_data) linked_list.append(node_1_data) # 4 3 2 1 -> 1 2 3 4 linked_list.sort(comparison_function=node_comparison_function) first_node = linked_list.head assert first_node.data == node_1_data assert first_node.previous_node is None assert first_node.next_node.data == node_2_data second_node = linked_list.head.next_node assert second_node is not None assert second_node.data == node_2_data assert second_node.previous_node.data == node_1_data assert second_node.next_node.data == node_3_data third_node = second_node.next_node assert third_node is not None assert third_node.data == node_3_data assert third_node.previous_node.data == node_2_data assert third_node.next_node.data == node_4_data fourth_node = third_node.next_node assert fourth_node is not None assert fourth_node.data == node_4_data assert fourth_node.previous_node.data == node_3_data assert fourth_node.next_node is None assert linked_list.tail.data == node_4_data linked_list = LinkedList() linked_list.append(node_1_data) linked_list.append(node_2_data) linked_list.append(node_3_data) linked_list.append(node_4_data) # 1 2 3 4 -> 4 3 2 1 linked_list.sort(comparison_function=node_comparison_function, reverse=True) first_node = linked_list.head assert first_node.data == node_4_data assert first_node.previous_node is None assert first_node.next_node.data == node_3_data second_node = linked_list.head.next_node assert second_node is not None assert second_node.data == node_3_data assert second_node.previous_node.data == node_4_data assert second_node.next_node.data == node_2_data third_node = second_node.next_node assert third_node is not None assert third_node.data == node_2_data assert third_node.previous_node.data == node_3_data assert third_node.next_node.data == node_1_data fourth_node = third_node.next_node assert fourth_node is not None assert fourth_node.data == node_1_data assert fourth_node.previous_node.data == node_2_data assert fourth_node.next_node is None assert linked_list.tail.data == node_1_data
class TestLinkedList(unittest.TestCase): def setUp(self): self.emptyList = LinkedList() self.oneItemList = LinkedList() self.twoItemList = LinkedList() self.fiveItemList = LinkedList() self.one = [3] self.two = [2, 9] self.five = [6, 1, 0, 5, 8] for i in self.one: self.oneItemList.append(i) for i in self.two: self.twoItemList.append(i) for i in self.five: self.fiveItemList.append(i) def testEmptyAppend(self): self.emptyList.append(4) self.assertEqual(self.emptyList.getPosition(0), 4) def testOneAppend(self): self.oneItemList.append(1) self.assertEqual(self.oneItemList.getPosition(0), 3) self.assertEqual(self.oneItemList.getPosition(1), 1) def testTwoAppend(self): self.twoItemList.append(6) self.assertEqual(self.twoItemList.getPosition(0), 2) self.assertEqual(self.twoItemList.getPosition(1), 9) self.assertEqual(self.twoItemList.getPosition(2), 6) def testEmptyPrepend(self): self.emptyList.prepend(4) self.assertEqual(self.emptyList.getPosition(0), 4) def testOnePrepend(self): self.oneItemList.prepend(1) self.assertEqual(self.oneItemList.getPosition(0), 1) def testTwoPrepend(self): self.twoItemList.prepend(6) self.assertEqual(self.twoItemList.getPosition(0), 6) self.assertEqual(self.twoItemList.getPosition(1), 2) self.assertEqual(self.twoItemList.getPosition(2), 9) def testEmptyInsertAfter(self): self.assertFalse(self.emptyList.insertAfter(1, 3)) def testOneInsertAfter(self): self.assertTrue(self.oneItemList.insertAfter(2, 0)) self.assertEqual(self.oneItemList.getPosition(1), 2) self.assertFalse(self.oneItemList.find(7)) def testTwoInsertAfter(self): self.assertTrue(self.twoItemList.insertAfter(7, 0)) self.assertEqual(self.twoItemList.getPosition(1), 7) self.assertFalse(self.twoItemList.find(3)) def testEmptyRemoveBeginning(self): self.assertFalse(self.emptyList.removeBeginning()) def testOneRemoveBeginning(self): self.assertTrue(self.oneItemList.removeBeginning()) self.assertFalse(self.oneItemList.getPosition(0)) def testTwoRemoveBeginning(self): self.assertTrue(self.twoItemList.removeBeginning()) self.assertEqual(self.twoItemList.getPosition(0), 9) def testEmptyRemoveAfter(self): self.assertFalse(self.emptyList.removeAfter(0)) def testOneRemoveAfter(self): self.assertFalse(self.oneItemList.removeAfter(0)) def testTwoRemoveAfter(self): self.assertTrue(self.twoItemList.removeAfter(0)) def testEmptyFind(self): self.assertFalse(self.emptyList.find(0)) def testOneFind(self): self.assertFalse(self.oneItemList.find(0)) self.assertTrue(self.oneItemList.find(3)) def testTwoFind(self): self.assertTrue(self.fiveItemList.find(8)) self.assertFalse(self.fiveItemList.find(3)) def testFiveFind(self): self.assertTrue(self.fiveItemList.find(0)) self.assertFalse(self.fiveItemList.find(2))
class LinkedListTestCase(unittest.TestCase): def setUp(self): self.headValue = 1 self.nValue = 2 self.nnValue = 3 self.l = LinkedList(self.headValue) def test_property(self): n = Node() n.value = 1 self.assertEqual(n.value, 1, "Property test") def test_linked_list_head_exist(self): self.assertTrue(isinstance(self.l.head, Node)) def test_linked_list_append_next(self): self.l.append(self.nValue) self.assertEqual(self.l.head._next.value, self.nValue, "append node next") def test_linked_list_append_prev(self): self.l.append(self.nValue) self.assertEqual(self.l.head._next.prev.value, self.l.head.value, "append node prev") def test_linked_list_many_time_append_next(self): self.l.append(self.nValue) self.l.append(self.nnValue) self.assertEqual(self.l.head._next.value, self.nValue, "append many time next") def test_linked_list_many_time_append_prev(self): self.l.append(self.nValue) self.l.append(self.nnValue) self.assertEqual(self.l.head._next._next.prev.value, self.nValue, "append many time prev") def test_call(self): self.l.append(self.nValue) self.l.append(self.nnValue) self.assertEqual(self.l.call(2).value, self.nnValue, "check call(2)") self.assertEqual(self.l.call(1).value, self.nValue, "check call(1)") self.assertEqual(self.l.call(0).value, self.headValue, "check call(0)") def test_delete(self): self.l.append(self.nValue) self.l.append(self.nnValue) self.l.delete(1) self.assertEqual(self.l.head._next.value, self.nnValue, "check delete function next") self.assertEqual(self.l.head._next.prev.value, self.headValue, "check delete function prev") '''
""" from linked_list import LinkedList def delete_mid_node(middle_node): if middle_node is None: return 0 if middle_node.next is not None: middle_node.value = middle_node.next.value middle_node.next = middle_node.next.next middle_node.next.next = None return middle_node linked_list = LinkedList() letters = ['a', 'b', 'c', 'd', 'e'] for let in letters: linked_list.append(let) print(str(linked_list)) mid_node = linked_list.get_node('c') print(str(mid_node)) print(str(delete_mid_node(mid_node))) print(str(linked_list))