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