def addlists_reverse2(L1, L2):
"""
Time = O(n), Space = O(1)
"""
def add(N1, N2, carry):
# we are done if both lists are null and the carry value is 0
if N1 is None and N2 is None and carry == 0:
return None
result = Node(0)
# add value and the data from L1 and L2
value = carry
if N1 is not None:
value += N1.data
if N2 is not None:
value += N2.data
result.data = value % 10
# recurse
if N1 is not None or N2 is not None:
more = add(N1.next if N1 is not None else None,
N2.next if N2 is not None else None,
1 if value >= 10 else 0)
result.next = more
return result
L = LinkedList()
L.head = add(L1.head, L2.head, 0)
return L
def partition_linkedlist2(L, x):
"""
Time = O(n), Space = O(n)
"""
before = LinkedList()
beforeStart = before.head
after = LinkedList()
afterStart = after.head
curr = L.head
while curr is not None:
next = curr.next
if curr.data < x:
# insert node into front of before list
curr.next = beforeStart
beforeStart = curr
else:
# insert node into front of after list
curr.next = afterStart
afterStart = curr
curr = next
# merge before list and after list
if not beforeStart:
return after
new_list = LinkedList()
new_list.head = beforeStart
# find end of before list, and merge the lists
while beforeStart.next:
beforeStart = beforeStart.next
beforeStart.next = afterStart
return new_list
class Stack:
def __init__(self) -> None:
self.__linked_list = LinkedList()
def is_empty(self) -> bool:
return self.__linked_list.is_empty()
def push(self, item: Any) -> None:
self.__linked_list.insert(item)
def pop(self) -> Any:
if self.is_empty():
raise ValueError('Stack is empty')
return self.__linked_list.delete(self.__linked_list.head.item)
def __iter__(self) -> LinkedListIterator:
return LinkedListIterator(self.__linked_list.head)
def reverseList(L):
prev = None
curr = L.head
while curr is not None:
temp = curr.next
curr.next = prev
prev = curr
curr = temp
return LinkedList(prev)
def addlists_reverse(L1, L2):
"""
Time = O(n), Space = O(1)
"""
size = L1.size() if L1.size() > L2.size() else L2.size()
L = LinkedList()
p1, p2 = L1.head, L2.head
carry = 0
for _ in range(size):
d1 = p1.data if p1 is not None else 0
d2 = p2.data if p2 is not None else 0
d = d1 + d2 + carry
if d >= 10:
d = d % 10
carry = 1
else:
carry = 0
L.add(d)
if p1 is not None:
p1 = p1.next
if p2 is not None:
p2 = p2.next
if carry == 1:
L.add(1)
return L
def addlists_forward(L1, L2):
"""
Time = O(n), Space = O(1)
"""
def add(N1, N2):
if N1 is None and N2 is None:
return (None, 0)
partial_sum = add(N1.next, N2.next)
data = N1.data + N2.data + partial_sum[1]
node = insert_before(partial_sum[0], data % 10)
carry = data // 10
return (node, carry)
def insert_before(N, data):
node = Node(data)
node.next = N
return node
def padlist(L, n):
padded = LinkedList()
padded.head = L.head
for _ in range(n):
L.add(0)
return padded
len1, len2 = L1.size(), L2.size()
if len1 < len2:
L1 = padlist(L1, len2 - len1)
else:
L2 = padlist(L2, len1 - len2)
L = LinkedList()
partial_sum = add(L1.head, L2.head)
L.head = partial_sum[0]
if partial_sum[1] != 0:
L.add(1)
return L
while node:
if node.value >= partition_value:
deleted_node = remove_node(node, previous, ll)
if right_side:
deleted_node.next_node = right_side
right_side = deleted_node
node = previous
previous = node
node = node.next_node
previous.next_node = right_side
def remove_node(node, previous, ll):
if previous:
previous.next_node = node.next_node
node.next_node = None
return node
else:
head = ll.head
ll.head = ll.head.next_node
previous = ll.head
return head
ll = LinkedList()
for val in [3, 5, 8, 5, 10, 2, 1]:
ll.insert(val)
partition_linked_list(ll, 8)
print(ll)
def __init__(self) -> None:
self.__linked_list = LinkedList()
def padlist(L, n):
padded = LinkedList()
padded.head = L.head
for _ in range(n):
L.add(0)
return padded
elif size == 2:
return [curr.next.next, curr.data == curr.next.data]
# result is an list of 2 elements
result = recurse(curr.next, size - 2)
if (result[0] is None) or (result[1] is False):
return result
else:
result[1] = curr.data == result[0].data
result[0] = result[0].next
return result
result = recurse(L.head, L.size())
return result[1]
# LeetCode 206. Reverse Linked List
def reverseList(L):
prev = None
curr = L.head
while curr is not None:
temp = curr.next
curr.next = prev
prev = curr
curr = temp
return LinkedList(prev)
l = LinkedList([1, 2, 3])
l.remove(2)
print(l)
from ds.linked_list import LinkedList
def find(one, other):
if not one or not other:
return False
for el_f, el_s in zip(one, other):
if el_f != el_s:
return False
return True
if __name__ == '__main__':
l1 = LinkedList()
l2 = LinkedList()
l1.append(1)
l1.append(4)
l1.append(3)
l2.append(1)
l2.append(2)
l2.append(3)
l2.append(4)
print(find(l1, l2))
def linked_list():
return LinkedList()