def sum_list1(h1, h2):
acc = 0
res = None
c1, c2 = h1, h2
while c1 != None or c2 != None:
if c1 != None:
v1 = c1.data
c1 = c1.next
else:
v1 = 0
if c2 != None:
v2 = c2.data
c2 = c2.next
else:
v2 = 0
val = v1 + v2 + acc
tmp = val % 10
acc = val / 10
if res:
res.append(tmp)
else:
res = Node(tmp)
if acc != 0:
res.append(acc)
return res
def test_for_multiple_nodes(self):
node2 = Node(2)
node1 = Node(1, node2)
self.assertIsNone(node2.next())
node1.append(3)
self.assertIsNotNone(node2.next(), None)
self.assertEqual(node2.next().value(), 3)
def create_linked_lists(root: TreeNode):
result = []
current_linked_list = Node(root)
while current_linked_list:
result.append(current_linked_list)
n = current_linked_list
next_linked_list: Node = None
while n:
if n.data.left:
if next_linked_list:
next_linked_list.append(n.data.left)
else:
next_linked_list = Node(n.data.left)
if n.data.right:
if next_linked_list:
next_linked_list.append(n.data.right)
else:
next_linked_list = Node(n.data.right)
n = n.tail
current_linked_list = next_linked_list
return result
runner._next._pre = runner
else:
runner = runner._next
l = l._next
return True
def remove_dups_2(l):
assert l != None, 'Empty list'
appeared = [l._item]
while l._next != None:
if l._next._item in appeared:
l._next = l._next._next
if l._next != None:
l._next._pre = l
else:
appeared.append(l._next._item)
l = l._next
return True
if __name__ == '__main__':
l = Node(np.random.randint(1, 10))
for i in range(np.random.randint(5, 10)):
l.append(np.random.randint(1, 10))
print('Before removal')
display(l)
remove_dups_2(l)
print('After:')
display(l)
def test_linked_list_append(self):
linked_list = Node(1, Node(2, Node(3, Node(4))))
another_linked_list = Node(1, Node(2, Node(3)))
another_linked_list.append(4)
self.assertEqual(linked_list, another_linked_list)
else:
seen.add(node.data)
prev = node
node = node.next
def delete_dupes2(node):
'''Without a buffer, using a leading node instead'''
while node.next is not None:
runner = node
while runner.next is not None:
if runner.next.data == node.data:
runner.next = runner.next.next
else:
runner = runner.next
node = node.next
arr = [3, 2, 2, 2, 3, 1, 3, 1, 2, 3]
head = Node(1)
for n in arr:
head.append(n)
print_nodes(head)
delete_dupes(head)
print_nodes(head)
from linked_list import Node a = Node(10) a.append(20) a.append(55) print(a)
def getLastNode(l):
assert l._item != None, 'Empty list'
while True:
l = l._next
if l._next == None:
break
return l
if __name__ == '__main__':
l = Node()
n = np.random.randint(1,10)
print('N: %d' %n)
if np.random.randint(0,2) > 0:
if (n % 2) == 0:
for i in range(n//2):
l.append(i)
for i in range(n//2):
l.append(n//2 - i -1)
else:
for i in range((n//2) + 1):
l.append(i)
for i in range(n//2):
l.append(n//2 - i -1)
else:
for i in range(n):
l.append(np.random.randint(0,10))
display(l)
result = check_palindrome(l)
print(result)
def test_for_single_node(self):
node = Node(1)
self.assertIsNone(node.next())
node.append(2)
self.assertIsNotNone(node.next(), None)
self.assertEqual(node.next().value(), 2)
