def partition(llist, partition): if llist.head is None: return current = llist.head leftTail = LinkedListNode(None, current) while current.value < partition: leftTail = leftTail.next current = current.next current = leftTail firstTime = True while current.next: if current.next.value >= partition: current = current.next else: if firstTime and leftTail.value: llist.head = leftTail firstTime = False temp = leftTail.next leftTail.next = current.next leftTail = current.next current.next = leftTail.next leftTail.next = temp print llist
def sum_lists_followup(ll_a, ll_b):
la = len(ll_a)
lb = len(ll_b)
if la > lb:
for i in range(la - lb):
ll_b.add_to_beginning(0)
elif lb > la:
for i in range(lb - la):
ll_a.add_to_beginning(0)
# return carry
def dfs(ll_a, ll_b, ll_n):
if not ll_a or not ll_b:
return 0
c = dfs(ll_a.next, ll_b.next, ll_n)
v = (c + ll_a.value + ll_b.value) % 10
c = (c + ll_a.value + ll_b.value) // 10
n = LinkedListNode(v)
if ll_n.head is None:
ll_n.head = ll_n.tail = n
else:
n.next = ll_n.head
ll_n.head = n
return c
ll = LinkedList()
c = dfs(ll_a.head, ll_b.head, ll)
if c:
n = LinkedListNode(c)
n.next = ll.head
ll.head = n
return ll
def reversed_list(node):
head = None
while node:
n = LinkedListNode(node.val)
n.next = head
head = n
node = node.next
return head
def ReverseLL2(ll): current = ll.head head = None while current: n = LinkedListNode(current.value) n.next = head head = n current = current.next ll_clone = LinkedList() ll_clone.head = head return (ll_clone)
def dfs(ll_a, ll_b, ll_n):
if not ll_a or not ll_b:
return 0
c = dfs(ll_a.next, ll_b.next, ll_n)
v = (c + ll_a.value + ll_b.value) % 10
c = (c + ll_a.value + ll_b.value) // 10
n = LinkedListNode(v)
if ll_n.head is None:
ll_n.head = ll_n.tail = n
else:
n.next = ll_n.head
ll_n.head = n
return c
def reverse_list_out_of_place(head):
if not head:
return None
if not head.next:
return head
prev = None
cur = head
while cur:
new_node = LinkedListNode(cur.value)
new_node.next = prev
prev = new_node
cur = cur.next
return prev
prev = None
cur = head
while cur:
new_node = LinkedListNode(cur.value)
new_node.next = prev
prev = new_node
cur = cur.next
return prev
head = LinkedListNode(1)
head.next = LinkedListNode(2)
head.next.next = LinkedListNode(3)
head.next.next.next = LinkedListNode(4)
li = LinkedList()
li.root = head
print li
new_head = reverse_list_inplace(head)
li.root = new_head
print li
new_new_head = reverse_list_out_of_place(new_head)
li_new = LinkedList()
li_new.root = new_new_head
print li_new
def Push(self, data):
new_node = LinkedListNode(data)
new_node.next = self.top
self.top = new_node
def deleteMiddleNode(self, node: LinkedListNode):
# Reference next node to current node
node.value = node.next.value
node.next = node.next.next
carry = int(curr_val / 10)
curr1 = curr1.next if curr1 else None
curr2 = curr2.next if curr2 else None
curr_output = curr_output.next
return output_list_head.next
n1 = LinkedListNode(1)
n2 = LinkedListNode(0)
n3 = LinkedListNode(9)
n4 = LinkedListNode(9)
n5 = LinkedListNode(9)
n6 = LinkedListNode(9)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = n6
print(LinkedList(n1))
m1 = LinkedListNode(7)
m2 = LinkedListNode(3)
m3 = LinkedListNode(2)
m1.next = m2
m2.next = m3
print(LinkedList(m1))
from LinkedList import LinkedListNode
from LinkedList import LinkedList
head = LinkedListNode('Angel Food')
b = LinkedListNode('Bundt')
c = LinkedListNode('Cheese')
d = LinkedListNode('Devils Food')
e = LinkedListNode('Eccles')
head.next = b
b.next = c
c.next = d
d.next = e
def kth_to_last_node(k, head):
count = 0
node = head
while node:
node = node.next
count += 1
if k > count:
raise Exception('k is larger than the list size')
stop_at = count - k
node = head
i = 0
while i < stop_at:
node = node.next
#!/usr/bin/env python
"""
Given a sorted linked list, delete all duplicates such that each element appears
only once.
For example,
Given 1->1->2, return 1->2.
Given 1->1->2->3->, return 1->2->3.
"""
from LinkedList import LinkedListNode
head = LinkedListNode(1)
head.next = LinkedListNode(1)
head.next.next = LinkedListNode(2)
# @params {LinkedListNode} head of a linked list
def remove_duplicates(head):
if not head or not head.next:
return head
slow_pointer = head #assign head to slow pointer vatriable
fast_pointer = head.next #assign next from head to fast_pointer variable
while fast_pointer:
if slow_pointer.data == fast_pointer.data: #if head and next matches
slow_pointer.data = fast_pointer.data
fast_pointer = fast_pointer.next
else:
slow_pointer = slow_pointer.next