def partition(chain: Node, target: int) -> LinkedList:
beforeStart = Node()
beforeEnd = Node()
afterStart = Node()
afterEnd = Node()
while (chain):
nex = chain.next
chain.next = None # Used so that we dont accidently create a circular linked list
if chain.val < target:
if beforeStart.val == None: # Kind of like a bool
beforeStart = chain
beforeEnd = beforeStart
else:
beforeEnd.next = chain
beforeEnd = chain
else:
if afterStart.val == None:
afterStart = chain
afterEnd = afterStart
else:
afterEnd.next = chain
afterEnd = chain
chain = nex
if not beforeStart:
return afterStart
beforeEnd.next = afterStart
return beforeStart
def partition(head, x):
if head.value >= x:
smaller_x = None
bigger_x = Node(head.value)
else:
smaller_x = Node(head.value)
bigger_x = None
runner = head.next
s = smaller_x
b = bigger_x
while runner:
if runner.value >= x:
if b:
b.next = Node(runner.value)
b = b.next
else:
b = Node(runner.value)
b.next = None
bigger_x = b
else:
if s:
s.next = Node(runner.value)
s = s.next
else:
s = Node(runner.value)
s.next = None
smaller_x = s
runner = runner.next
s.next = bigger_x
print('done')
printLinkedList(smaller_x)
def sumReverseOrder(l1, l2):
carry = 0
dummy = Node(0)
ans = dummy
while l1 and l2:
r = (l1.val + l2.val + carry) % 10
dummy.next = Node(r)
carry = (l1.val + l2.val + carry) / 10
dummy = dummy.next
l1 = l1.next
l2 = l2.next
while l1:
r = (l1.val + carry) % 10
dummy.next = Node(r)
carry = (l1.val + carry) / 10
dummy = dummy.next
l1 = l1.next
while l2:
r = (l2.val + carry) % 10
dummy.next = Node(r)
carry = (l2.val + carry) / 10
dummy = dummy.next
l2 = l2.next
return ans.next
def sumForwardOrder(l1, l2):
'''
5 1 => 1 5
6 7 8 => 8 7 6
3 reversals
stack same space as 3 reversals except we can do it without modifying the ll
0 5 1
6 7 8
6 12 9
9 9 9
9 9 9
18 18 18
19 9 8
1/ pad zeros at front of shortler list
2/ add and dont propagate carry
3/ check if next.val >= 10, then add 1 to curr.val and check next.val to next.val % 10
:param l1:
:param l2:
:return:
'''
n1, n2 = l1.size(), l2.size()
if n1 < n2:
for i in range(n2 - n1):
l1.addToFront(0)
elif n1 > n2:
for i in range(n1 - n2):
l2.addToFront(0)
print("Both lists are now equal")
l1, l2 = l1.head, l2.head
dummy = Node(0)
first = dummy
while l1 and l2:
dummy.next = Node(l1.val + l2.val)
dummy = dummy.next
l1 = l1.next
l2 = l2.next
start = first.next
print(start.val)
final = Node(1) if start.val >= 10 else Node(0)
start.val = start.val % 10 if start.val >= 10 else start.val
answer = final
while start is not None and start.next is not None:
if start.next.val >= 10:
start.val += 1
start.next.val = start.next.val % 10
final.next = start
final = final.next
start = start.next
return answer.next if answer.val == 0 else answer
def push(self, item):
n = Node(item)
if self.top == None:
self.top = n
else:
n.next = self.top
self.top = n
def test_LinkedList():
l1 = LinkedList()
l1.head = Node('Mon')
e2 = Node('Tue')
e3 = Node('Wed')
l1.head.next = e2 # link first Node to second Node
e2.next = e3 # link secodn node to third Node
return l1
def insert(self, elem):
node = Node(elem)
node.next = None
if self.head == None:
self.head = node
self.tail = node
else:
self.tail.next = node
self.tail = node
self.length += 1
def insert(self, elem):
node = Node(elem)
node.next = None
if self.head == None:
self.head = node
self.tail = node
else:
self.tail.next = node
self.tail = node
self.length += 1
def correctInsertion(self, data):
newNode = Node(data)
current_node = self.root.next
previous_node = self.root
while (current_node.next != None and current_node.data > data):
previous_node = current_node
current_node = current_node.next
previous_node.next = newNode
newNode.next = current_node
self.length += 1
def removeDups(self, head):
curr = head
dummy = Node(0)
while curr is not None:
if curr.val not in self.cache:
self.cache[curr.val] = True
dummy.next = curr
dummy = dummy.next
curr = curr.next
return head
ptr1 = lst #move ptr1 back to beginning
while ptr1 != ptr2:
ptr1 = ptr1.next
ptr2 = ptr2.next #increment both by 1 each time
return ptr1 #return node where they met
return False
"""
Tests
"""
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n4 = Node(4)
lst1 = n1
lst1.next = n2
n2.next = n3
n3.next = n4
assert DetectCycle(lst1) is False
lst2 = n1
lst2.next = n2
n2.next = n3
n3.next = n2
assert DetectCycle(lst2) is n2
# high score = 32
# n_players = 9
# last_marble = 25
# n_players = 9
# last_marble = 46
# high score = 8317
# n_players = 10
# last_marble = 1618
# high score = 425688
n_players = 411
last_marble = 71170 * 100
players = [0 for i in range(n_players)]
player = 0
node = Node(0)
node.next = node
node.prev = node
c_marble = 1
while c_marble <= last_marble:
if (not c_marble % 23):
players[player] += c_marble
for i in range(7):
node = node.prev
players[player] += node.data
node.prev.next = node.next
node.next.prev = node.prev
node = node.next
a = node.data
else:
new_node = Node(c_marble, node.next.next, node.next)
def Push(self, elem):
node = Node(elem)
node.next = self.top
self.top = node
self.length += 1
def Push(self, elem):
node = Node(elem)
node.next = self.top
self.top = node
self.length += 1
ptr1 = lst #move ptr1 back to beginning
while ptr1 != ptr2:
ptr1 = ptr1.next
ptr2 = ptr2.next #increment both by 1 each time
return ptr1 #return node where they met
return False
"""
Tests
"""
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n4 = Node(4)
lst1 = n1
lst1.next = n2
n2.next = n3
n3.next = n4
assert DetectCycle(lst1) is False
lst2 = n1
lst2.next = n2
n2.next = n3
n3.next = n2
assert DetectCycle(lst2) is n2
# printList.py 연결 리스트 프린트
from linkedList import List, Node
print('01.printlist()_____________\n')
# ------------------------------------------------
mylist = List()
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n4 = Node(4)
n5 = Node(5)
mylist.head = n1
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
mylist.size = 5
mylist.printlist()