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