def test_head_tail(self): single_list = SingleList([]) assert single_list.head is None assert single_list.tail is None node1 = Node(1) single_list.add_last(node1) assert single_list.head is node1 assert single_list.tail is node1 single_list.pop() assert single_list.head is None assert single_list.tail is None node2 = Node(2) single_list.add_first(node1) single_list.add_last(node2) assert single_list.head is node1 assert single_list.tail is node2 single_list = SingleList([1, 2, 3]) assert single_list.head.val is 1 assert single_list.tail.val is 3 single_list += SingleList([4, 5, 6]) assert single_list.head.val is 1 assert single_list.tail.val is 6 single_list += SingleList([]) assert single_list.head.val is 1 assert single_list.tail.val is 6
def setUp(self): self.first_list = SingleList() self.second_list = SingleList() self.first_list.insert_head(Node(3)) self.first_list.insert_head(Node(5)) self.first_list.insert_tail(Node(7)) self.second_list.insert_head(Node(1)) self.second_list.insert_tail(Node(11))
def test_add_last(self): single_list = SingleList([]) with pytest.raises(TypeError): single_list.add_last(1) single_list.add_last(Node(1)) assert single_list == SingleList([1]) single_list.add_last(Node(2)) assert single_list == SingleList([1, 2]) assert len(single_list) == 2
def test_previous(self): single_list = SingleList([]) assert single_list.previous(single_list.head) is None assert single_list.previous(single_list.tail) is None assert single_list.previous(Node()) is None single_list = SingleList([1, 2, 3]) assert single_list.previous(single_list.head) is single_list._dummyHead assert single_list.previous(single_list.tail).val == 2 assert single_list.previous(Node(2)) is None assert single_list.previous(None) is None assert single_list.previous(single_list[1]).val == 1
def addTwoNumbers(l1, l2): res = Node(0, None) pointer = res acum = 0 while (l1 or l2) or acum > 0: suma = (l1.value if l1 else 0) + (l2.value if l2 else 0) + acum acum = suma // 10 pointer.value = suma % 10 l1 = l1.next if l1 else None l2 = l2.next if l2 else None if l1 or l2 or acum: pointer.next = Node(0, None) pointer = pointer.next return res
def test_iadd(self): single_list = SingleList([]) single_list += SingleList([]) assert single_list == SingleList([]) single_list += SingleList([1, 2, 3]) assert single_list == SingleList([1, 2, 3]) single_list += SingleList([]) assert single_list == SingleList([1, 2, 3]) single_list += SingleList([4]) assert single_list == SingleList([1, 2, 3, 4]) single_list += None assert single_list == SingleList([1, 2, 3, 4]) single_list += Node(5) assert single_list == SingleList([1, 2, 3, 4, 5]) single_list += Node() assert single_list == SingleList([1, 2, 3, 4, 5, None])
def test_len(self): single_list = SingleList([]) assert len(single_list) == 0 single_list = SingleList([1, 2, 3]) assert len(single_list) == 3 single_list.add_last(Node(0)) assert len(single_list) == 4 single_list.pop() assert len(single_list) == 3
def test_remove(self): single_list = SingleList([]) with pytest.raises(ValueError): single_list.remove(0) single_list.remove(single_list.head) assert single_list.tail is None assert single_list.head is None assert len(single_list) == 0 assert single_list == SingleList([]) single_list = SingleList([1, 2, 3]) single_list.remove(1) assert single_list == SingleList([2, 3]) single_list.remove(3) assert single_list == SingleList([2]) assert single_list.tail.val == 2 assert single_list.head.val == 2 assert len(single_list) == 1 with pytest.raises(ValueError): single_list.remove(3) single_list.remove(2) assert single_list.tail is None assert single_list.head is None assert len(single_list) == 0 single_list = SingleList([1, 2, 3]) single_list.remove(single_list.head) assert single_list == SingleList([2, 3]) assert single_list.tail.val == 3 assert single_list.head.val == 2 assert len(single_list) == 2 single_list.remove(single_list.tail) assert single_list == SingleList([2]) assert single_list.tail.val == 2 assert single_list.head.val == 2 assert len(single_list) == 1 with pytest.raises(ValueError): single_list.remove(Node(1)) single_list = SingleList([1, 2, 3]) single_list.remove(single_list[1]) assert single_list.tail.val == 3 assert single_list.head.val == 1 assert len(single_list) == 2
def test_index(self): single_list = SingleList([]) with pytest.raises(ValueError): single_list.index(0) with pytest.raises(ValueError): single_list.index(Node()) with pytest.raises(ValueError): single_list.index(single_list.head) with pytest.raises(ValueError): single_list.index(single_list.tail) single_list = SingleList([1, 2, 3]) assert single_list.index(1) == 0 assert single_list.index(2) == 1 assert single_list.index(3) == 2 assert single_list.index(single_list[0]) == 0 assert single_list.index(single_list[1]) == 1 assert single_list.index(single_list[2]) == 2 assert single_list.index(single_list.head) == 0 assert single_list.index(single_list.tail) == len(single_list) - 1
def mergeTwoLists(l1, l2): newList = Node(0,None) pos = newList while (l1 and l2): if l1.value < l2.value: pos.next = l1 pos = pos.next l1 = l1.next else: pos.next = l2 pos = pos.next l2 = l2.next while l1: pos.next = l1 pos = pos.next l1 = l1.next while l2: pos.next = l2 pos = pos.next l2 = l2.next return newList.next #Not neccesary to use first node with "0"
def test_replace(self): single_list = SingleList([]) with pytest.raises(IndexError): single_list.replace(0, Node()) with pytest.raises(TypeError): single_list.replace(single_list.tail, Node()) single_list = SingleList([1, 2, 3]) node1 = Node(2) single_list.replace(0, node1) assert single_list.head is node1 assert single_list == SingleList([2, 2, 3]) node2 = Node(4) single_list.replace(single_list.tail, node2) assert single_list.tail is node2 assert single_list == SingleList([2, 2, 4]) node3 = Node(5) single_list.replace(1, node3) assert single_list[1] is node3 assert single_list == SingleList([2, 5, 4]) with pytest.raises(ValueError): single_list.replace(Node(), Node(6))
def test_setitem(self): single_list = SingleList([]) with pytest.raises(TypeError): single_list[0] = 0 with pytest.raises(IndexError): single_list[0] = Node(0) single_list = SingleList([1, 2, 3]) with pytest.raises(TypeError): single_list[0] = 0 single_list[0] = Node(0) assert single_list == SingleList([0, 2, 3]) single_list[1] = Node(1) assert single_list == SingleList([0, 1, 3]) single_list[-1] = Node(-1) assert single_list == SingleList([0, 1, -1]) single_list[-2] = Node(-2) assert single_list == SingleList([0, -2, -1]) with pytest.raises(IndexError): single_list[-4] = Node(-4) with pytest.raises(IndexError): single_list[3] = Node(3)
pointer = res acum = 0 while (l1 or l2) or acum > 0: suma = (l1.value if l1 else 0) + (l2.value if l2 else 0) + acum acum = suma // 10 pointer.value = suma % 10 l1 = l1.next if l1 else None l2 = l2.next if l2 else None if l1 or l2 or acum: pointer.next = Node(0, None) pointer = pointer.next return res if __name__ == '__main__': a3 = Node(3, None) a2 = Node(4, a3) a1 = Node(2, a2) b3 = Node(4, None) b2 = Node(6, b3) b1 = Node(5, b2) c = addTwoNumbers(a1, b1) print("Sum of {} and {} is {}".format(a1.printList(), b1.printList(), c.printList())) b3 = Node(8, None) b2 = Node(6, b3) b1 = Node(5, b2)
pos = pos.next l1 = l1.next else: pos.next = l2 pos = pos.next l2 = l2.next while l1: pos.next = l1 pos = pos.next l1 = l1.next while l2: pos.next = l2 pos = pos.next l2 = l2.next return newList.next #Not neccesary to use first node with "0" if __name__ == '__main__': n = Node (7, None) m = Node (5, n) c = Node (4, m) b = Node (3, c) a = Node (1, b) f = Node (6, None) e = Node (4, f) d = Node (2, e) newlist = mergeTwoLists(a, d) x= newlist while x: print(x.value) x = x.next
return head.next while x > n + 1: pointer = pointer.next x -= 1 pointer.next = pointer.next.next return head def __getPosition(node): if not node.next: return 1 return __getPosition(node.next) + 1 if __name__ == "__main__": e = Node(5, None) d = Node(4, e) c = Node(3, d) b = Node(2, c) a = Node(1, b) l1 = removeNthFromEndv1(a, 2) print("Removed to 2nd element from end in version 1 is {}".format( l1.printList())) e = Node(5, None) d = Node(4, e) c = Node(3, d) b = Node(2, c) a = Node(1, b) l1 = removeNthFromEndv2(a, 2)
eveninit = head.next evenpointer = eveninit oddpointer = head while eveninit and evenpointer and oddpointer: oddpointer.next = evenpointer.next oddpointer = evenpointer.next if evenpointer.next else oddpointer if evenpointer and evenpointer.next: evenpointer.next = oddpointer.next evenpointer = evenpointer.next else: break oddpointer.next = eveninit return head if __name__ == "__main__": e = Node("e", None) d = Node("d", e) c = Node("c", d) b = Node("b", c) a = Node("a", b) newlist = oddEvenList(a) print("Oreder list odd-even is {}".format(newlist.printList())) f = Node("f",None) e = Node("e", f) d = Node("d", e) c = Node("c", d) b = Node("b", c) a = Node("a", b)
def _enqueue(self, e): self._data.add_last(Node(e))
from single_list import Node def hasCycle(head): slow = head faster = head while slow and faster and faster.next: slow = slow.next faster = faster.next.next if faster.next else None if slow == faster: return True return False if __name__ == "__main__": n4 = Node(-4, None) n3 = Node(0, n4) n2 = Node(2, n3) n1 = Node(3, n2) print("Has cycle? {}".format(hasCycle(n1))) n4.next = n2 #loop print("Has cycle? {}".format(hasCycle(n1))) n5 = Node(6, None) print("Has cycle? {}".format(hasCycle(n5))) ne = Node(9, None) nd = Node(8, ne) nc = Node(11, nd) nb = Node(5, nc) na = Node(1, nb) print("Has cycle? {}".format(hasCycle(na))) ne.next = nb
def push(self, e): self._data.add_last(Node(e))
def test_insert(self): single_list = SingleList([]) with pytest.raises(IndexError): single_list.insert(-1, Node(1)) with pytest.raises(IndexError): single_list.insert(1, Node(1)) with pytest.raises(TypeError): single_list.insert(-1, 1) single_list.insert(0, Node(1)) assert single_list == SingleList([1]) single_list.insert(0, Node(2)) assert single_list == SingleList([2, 1]) single_list.insert(1, Node(3)) assert single_list == SingleList([2, 3, 1]) single_list.insert(3, Node(4)) assert single_list == SingleList([2, 3, 1, 4]) assert single_list.head.val == 2 assert single_list.tail.val == 4 assert len(single_list) == 4 single_list = SingleList([1]) single_list.insert(single_list.head, Node(2)) assert single_list == SingleList([1, 2]) single_list.insert(single_list.head, Node(3), before=True) assert single_list == SingleList([3, 1, 2]) single_list.insert(single_list.tail, Node(4)) assert single_list == SingleList([3, 1, 2, 4]) single_list.insert(single_list.tail, Node(5), before=True) assert single_list == SingleList([3, 1, 2, 5, 4]) single_list.insert(single_list[2], Node(6)) assert single_list == SingleList([3, 1, 2, 6, 5, 4]) single_list.insert(single_list[2], Node(7), before=True) assert single_list == SingleList([3, 1, 7, 2, 6, 5, 4]) assert single_list.head.val == 3 assert single_list.tail.val == 4 assert len(single_list) == 7
def _init_loop_queue(self): cur = self._front for _ in range(self._capacity): cur._next = Node() cur = cur.next cur._next = self._front # circular singly linked list
def __init__(self, capacity): self._capacity = capacity self._size = 0 self._front = self._tail = Node() self._init_loop_queue()