def sll_swap_node(sll: Singlellist, x, y) -> None: if x == y: return # S1: find prev_x, curr_x ptr = sll.head while ptr.next.value != x: ptr = ptr.next prev_x = ptr curr_x = ptr.next # S1: find prev_y, curr_y ptr = sll.head while ptr.next.value != y: ptr = ptr.next prev_y = ptr curr_y = ptr.next # S2: change prev if prev_x is None: # x is the head sll.head = curr_y else: prev_x.next = curr_y if prev_y is None: # y is the head sll.head = curr_x else: prev_y.next = curr_x # S3: change next temp = curr_x.next curr_x.next = curr_y.next curr_y.next = temp
class LinkedQueue(Singlellist): """FIFO queue implementation using a single linked list for storage""" def __init__(self): """Create an empty queue""" self._data = Singlellist() def __len__(self): """Return the number of elements in the queue""" return len(self._data) def is_empty(self): """Return True if the queue is empty""" return len(self._data) == 0 def first(self): """Return(but do not remove) the element at the front if the queue""" if self.is_empty(): raise Empty("Queue is empty") return self._data.head.value def dequeue(self): """Remove and return the first element if the queue(i.e., FIFO). Raisee Empty exception if the dueue is empty""" if self.is_empty(): raise Empty("Queue is empty") node = self._data.remove_first() return node.value def enqueue(self, e): """Add an element to the back of the queue""" self._data.add_last(e)
def test_contains(self): sll = Singlellist() self.assertNotIn(1, sll) sll = Singlellist([1, 2, 3]) self.assertIn(1, sll) self.assertNotIn(0, sll) self.assertNotIn('0', sll)
def reverse_sll_2(sll: Singlellist) -> Singlellist: if len(sll) == 1: return sll head = sll.remove_first() head.next = None reverse_sll_2(sll).tail.next = head sll.tail = head return sll
def concatenating_linked_lists( l1: Singlellist, l2: Singlellist, ) -> Singlellist: result = Singlellist() result.head = l1.head l1.tail.next = l2.head return result
def test_remove_first(self): sll = Singlellist([1, 2, 3]) sll.remove_first() self.assertEqual(sll[0], 2) sll.remove_first() self.assertEqual(sll[0], 3) sll.remove_first() self.assertEqual(sll.is_empty(), True)
def test_remove_all(self): sll = Singlellist([1, 1, 2, 3, 3]) sll.remove_all(1) self.assertEqual(str(sll), "SLL[2, 3, 3]") sll.remove_all(3) self.assertEqual(str(sll), "SLL[2]") sll.remove_all(2) self.assertEqual(sll.is_empty(), True)
def reverse_sll_loop(sll: Singlellist) -> Singlellist: if len(sll) == 1: return sll head = sll.head prev_node = None curr_node = sll.head while curr_node is not None: next_node = curr_node.next curr_node.next = prev_node prev_node = curr_node curr_node = next_node sll.head = sll.tail sll.tail = head
def test_add_last(self): sll = Singlellist() self.assertEqual(sll.tail, None) sll.add_last(1) self.assertEqual(sll.tail.value, 1) sll.add_last(2) self.assertEqual(sll.tail.value, 2)
def test_add_first(self): sll = Singlellist() self.assertEqual(sll.head, None) sll.add_first(1) self.assertEqual(sll.head.value, 1) sll.add_first(2) self.assertEqual(sll.head.value, 2)
def __init__(self): """Create an empty queue""" self._data = Singlellist()
def count_num(sll: Singlellist) -> int: if sll.head is None: return 0 sll.remove_first() return 1 + count_num(sll)
def test_search(self): sll = Singlellist([1, 2, 3]) self.assertTrue(1 in sll) self.assertFalse(0 in sll)
def test_change_all(self): sll = Singlellist([1, 1, 2, 3, 3]) sll.change_all(1, 0) self.assertEqual(str(sll), "SLL[0, 0, 2, 3, 3]") sll.change_all(3, 4) self.assertEqual(str(sll), "SLL[0, 0, 2, 4, 4]")
def test_change(self): sll = Singlellist([1, 2, 3]) sll.change(1, 0) self.assertEqual(sll.head.value, 0) sll.change(3, 4) self.assertEqual(sll.tail.value, 4)
class LinkedStack(Singlellist): """ LIFO Srtack implementation using Python list as underlyinh storage. """ def __init__(self): """Create and empty stack. """ self._data = Singlellist() def __len__(self): """Return the number of elements in the stack. Time Complexity: O(1) """ return len(self._data) def __str__(self): """ Show the stack properly. Time Complexity: O(n) """ if self.is_empty(): s1 = '| ' + "".center(5) + ' |' + '\n' s2 = '-' * 9 return s1 + s2 else: s = [] for i in range(len(self._data) - 1, -1, -1): ele = self._data[i] s1 = '| ' + ele.__repr__().center(5) + ' |' + '\n' s2 = '-' * 9 + '\n' s.append(s1 + s2) return ''.join(s) def is_empty(self): """Return True if the stack is empty Time Complexity: O(1) """ return len(self._data) == 0 def push(self, e): """Add element to the top of the stack Time Complexity: O(1) Note: "*" in here means amortization """ self._data.add_last(e) def top(self): """ Return (but not remove) at the top of the stack. Raise Empty exception if the stack in empty. Time Complexity: O(1) """ if self.is_empty(): raise Empty("Stack in empty!") return self._data.tail.value def pop(self): """ Remove and return the element from the top of the stack(LIFO) Raise Empty exception if the stack is empty. Time Complexity: O(1) """ if self.is_empty(): raise Empty("Stack is empty!") ele = self._data.tail.value self._data.remove_last() return ele
def test_remove(self): sll = Singlellist([1, 2, 3]) sll.remove(1) self.assertEqual(sll.head.value, 2) sll.remove(3) self.assertEqual(sll.tail.value, 2)
def test_remove_last(self): sll = Singlellist([1, 2, 3]) sll.remove_last() self.assertEqual(sll[1], 2)
def test_init_items(self): sll = Singlellist([1, 2, 3]) self.assertEqual(len(sll), 3) self.assertEqual(sll.head.value, 1) self.assertEqual(sll.tail.value, 3) self.assertEqual(str(sll), 'SLL[1, 2, 3]')
def __init__(self): """Create and empty stack. """ self._data = Singlellist()
def test_insert_after(self): sll = Singlellist([1, 2, 3]) sll.insert_after(1, 11) self.assertEqual(sll[1], 11) sll.insert_after(3, 33) self.assertEqual(sll[4], 33)
def reverse_sll_1(sll: Singlellist) -> Singlellist: if len(sll) == 1: return sll head = sll.remove_first() reverse_sll_1(sll).add_last(head.value) return sll
def test_empty(self): sll = Singlellist() self.assertEqual(sll.is_empty(), True) sll.add_first(1) self.assertEqual(sll.is_empty(), False)