def reverseKGroup(self, head, k):
"""
:type head: ListNode
:type k: int
:rtype: ListNode
"""
# Get Length
p = head
ll = 0
while p is not None:
p = p.next
ll += 1
# reverse
p = head
head = ListNode(0)
head.next = p
prev_end = head
for i in range(0, ll // k):
cur_start = cur_end = prev_end.next
for j in range(0, k - 1):
cur_end = cur_end.next
if cur_end is None:
next_start = None
else:
next_start = cur_end.next
p, q, r = prev_end, prev_end.next, prev_end.next.next
for j in range(0, k):
q.next = p
p, q = q, r
if r is not None:
r = r.next
cur_start.next = next_start
prev_end.next = cur_end
prev_end = cur_start
return head.next
def reverseBetween(self, head, m, n):
"""
:type head: ListNode
:type m: int
:type n: int
:rtype: ListNode
"""
if head is None or head.next is None or m == n:
return head
head, p = ListNode(0), head
head.next = p
p, q, r = head, head.next, head.next.next
n -= m
m -= 1
while m > 0:
p, q = q, r
if r is not None:
r = r.next
m -= 1
flag1, flag2 = p, q
n += 1
while n > 0:
q.next = p
n -= 1
if n == 0:
flag1.next, flag2.next = q, r
break
p, q = q, r
if r is not None:
r = r.next
return head.next
def insertionSortList(self, head):
if not head or not head.next:
return head
dummy_head = ListNode(-1)
dummy_head.next = head
pre = dummy_head
cur = dummy_head
while cur.next:
if cur.next.val < pre.next.val:
pre = dummy_head
while pre.next.val < cur.next.val:
pre = pre.next
if pre != cur:
# insert tmp after pre
tmp = cur.next
cur.next = tmp.next
tmp.next = pre.next
pre.next = tmp
else:
cur = cur.next
return dummy_head.next
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
min_node, max_node = ListNode(-2**32), ListNode(2**32 - 1)
self.lists = [min_node]
for ele in lists:
self.lists.append(ele if ele else max_node)
self.length = len(lists)
if not self.length:
return
else:
dummy_head = ListNode(None)
node = dummy_head
for i in range(self.length):
if not self.lists[i]:
self.lists[i] = max_node
self.createLoserTree()
while self.lists[self.loser_tree[0]] != max_node:
node.next = self.lists[self.loser_tree[0]]
node = node.next
if self.lists[self.loser_tree[0]].next:
self.lists[self.loser_tree[0]] = self.lists[
self.loser_tree[0]].next
else:
self.lists[self.loser_tree[0]] = max_node
self.adjustTree(self.loser_tree[0])
node.next = None
return dummy_head.next
def reverseList(self, head: ListNode) -> ListNode:
if not head:
return None
head_1, head_2 = ListNode(0), ListNode(0)
head_1.next = head
while head_1.next:
node = head_1.next
head_1.next = node.next
node.next = head_2.next
head_2.next = node
return head_2.next
def removeElements(self, head: ListNode, val: int) -> ListNode:
dummy = ListNode(None)
dummy.next = head
pre, cur = dummy, head
while cur:
if cur.val == val:
cur = cur.next
pre.next = cur
else:
pre = cur
cur = cur.next
return dummy.next
def deleteDuplicates(self, head: ListNode) -> ListNode:
dummy = ListNode(None)
dummy.next = head
pre, cur = dummy, head
while cur and cur.next:
if cur.val == cur.next.val:
node = cur.next.next
while node and node.val == cur.val:
node = node.next
pre.next = node
cur = node
else:
pre, cur = cur, cur.next
return dummy.next
def reverseListIterative(self, head: ListNode) -> ListNode:
# First store the elements in a normal list: stack while scanning though the linked list
current = head
stack = []
while current.val:
stack.append(current.val)
current = current.next
reverse = ListNode(stack.pop())
current = reverse
# Build the reverse list by poping the element from the stack one after another
while stack:
current.next = ListNode(stack.pop())
current = current.next
return reverse
def partition(self, head: ListNode, x: int) -> ListNode:
p0, p1 = ListNode(0), ListNode(0)
head0, head1 = p0, p1
while head is not None:
if head.val < x:
p0.next = head
p0 = p0.next
else:
p1.next = head
p1 = p1.next
head = head.next
p0.next = head1.next
p1.next = None
return head0.next
def swapPairs(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
p = head
head = ListNode(0)
head.next = p
p = head
while p.next is not None and p.next.next is not None:
tp1, tp2, q = p.next, p.next.next, p.next.next.next
p.next, tp2.next, tp1.next = tp2, tp1, q
p = tp1
return head.next
def build_testing_node_sequence(self):
node_1 = ListNode(-2)
node_0 = ListNode(-1)
node_2 = ListNode(-3)
node_1.insert_precursor(node_0)
node_1.insert_successor(node_2)
return node_0
def removeElements(self, head, val):
"""
:type head: ListNode
:type val: int
:rtype: ListNode
"""
p = head
head = ListNode(0)
head.next = p
p = head
while p is not None and p.next is not None:
while p.next is not None and p.next.val == val:
p.next = p.next.next
p = p.next
return head.next
def __init__(self, initial_iterable=None):
"""
Constructor
Args:
initial_iterable (iterable): iterable object which has the data used to be saved in nodes of this list
"""
self._head = ListNode(data=None, precursor=None, successor=None)
self._tail = ListNode(data=None, precursor=self._head, successor=None)
self._head._successor = self._tail
self._size = 0
if initial_iterable is not None:
self.copy_from(initial_iterable)
def partition(self, head: ListNode, x: int) -> ListNode:
d_l = ListNode(None)
d_h = ListNode(None)
n_l, n_h = d_l, d_h
while head:
if head.val < x:
n_l.next = head
n_l = n_l.next
else:
n_h.next = head
n_h = n_h.next
head = head.next
n_l.next = d_h.next
n_h.next = None
return d_l.next
def deleteDuplicates(self, head: 'ListNode') -> 'ListNode':
if head is None:
return None
p = ListNode(0)
p.next = head
head = p
while p.next is not None and p.next.next is not None:
if p.next.val == p.next.next.val:
current = p.next.val
while p.next.next is not None and p.next.next.val == current:
p.next.next = p.next.next.next
p.next = p.next.next
else:
p = p.next
return head.next
def removeNthFromEnd(self, head, n):
"""
:type head: ListNode
:type n: int
:rtype: ListNode
"""
node_1, node_2 = ListNode(None), head
node_1.next = head
head = node_1
for i in range(1, n):
node_2 = node_2.next
while node_2.next:
node_1 = node_1.next
node_2 = node_2.next
node_1.next = node_1.next.next
return head.next
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
dummy = ListNode(None)
dummy.next = head
prev, cur = dummy, head
i = 1
while i<m:
prev, cur = cur, cur.next
i += 1
head, tail = prev, cur
while i<=n:
next_node = cur.next
cur.next = prev
prev, cur = cur, next_node
i += 1
head.next = prev
tail.next = cur
return dummy.next
def removeNthFromEnd(self, head, n):
dummy = ListNode(-1)
dummy.next = head
pre = dummy
cur = head
end = head
for i in range(1, n):
end = end.next
while end.next:
pre = pre.next
cur = cur.next
end = end.next
pre.next = cur.next
return dummy.next
def make_cycle_list(L: list, pos) -> ListNode:
"""
Almost make a circle list
"""
node = ListNode(L[0])
res = node
pointer = 1
count = 1
# Add next node
while count < 3 * len(L):
node.next = ListNode(L[pointer])
node = node.next
if pointer % len(L) == len(L) - 1:
pointer = pos
else:
pointer += 1
count += 1
return res
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
dummy_N, dummy_O = ListNode(0), ListNode(0)
dummy_O.next = head
length, node = 0, head
while node:
length += 1
node = node.next
node_N = dummy_N
for _ in range(length // k):
tail = dummy_O.next
for _ in range(k):
node_O = dummy_O.next
dummy_O.next = node_O.next
node_O.next = node_N.next
node_N.next = node_O
node_N = tail
node_N.next = dummy_O.next
return dummy_N.next
def mergeTwoListsIterative(self, l1: ListNode, l2: ListNode) -> ListNode:
if l1 is None:
return l2
elif l2 is None:
return l1
# Trick to initialize
res = ListNode(0)
node = res
while l1 or l2:
if (l1 and l2 and l1.val < l2.val) or (not l2):
node.val = l1.val
l1 = l1.next
elif (l1 and l2 and l1.val >= l2.val) or (not l1):
node.val = l2.val
l2 = l2.next
if l1 or l2:
node.next = ListNode(0)
node = node.next
return res
def sortArray_Radix(self, nums: List[int]) -> List[int]:
head = ListNode(None)
node = head
max_val = min_val = nums[0]
for num in nums:
if num > max_val:
max_val = num
if min_val > num:
min_val = num
node.next = ListNode(num)
node = node.next
if min_val < 0:
val = max(max_val, abs(min_val))
else:
val = max_val
key_count = len(str(val))
for i in range(key_count):
head = self.collect(self.distribute(head, i))
return self.traverse(head)
def swapPairs(self, head: ListNode) -> ListNode:
if not head:
return head
cur = ListNode(None)
cur.next = head
head = cur
while True:
if cur.next:
node_1 = cur.next
if node_1.next:
node_2 = node_1.next
cur.next = node_2
node_1.next = node_2.next
node_2.next = node_1
cur = node_1
else:
break
else:
break
return head.next
def removeNthFromEnd(self, head, n):
"""
:type head: ListNode
:type n: int
:rtype: ListNode
"""
# get length
p = head
ll = 0
while p is not None:
ll += 1
p = p.next
on = ll + 1 - n
# delete node
p = ListNode(0)
p.next = head
q = p
for _ in range(1, on):
q = q.next
q.next = q.next.next
return p.next
def isPalindrome(self, head: ListNode) -> bool:
dummy1, dummy2 = ListNode(None), ListNode(None)
dummy1.next = head
slow = fast = dummy1
while fast and fast.next:
slow = slow.next
fast = fast.next.next
cur = slow.next
while cur:
node = cur.next
cur.next = dummy2.next
dummy2.next = cur
cur = node
slow, fast = dummy1, dummy2
while slow and fast:
if slow.val==fast.val:
slow = slow.next
fast = fast.next
else:
return False
else:
return True
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
dummy = ListNode(None)
dummy.next = head
i = 1
head = dummy
while i<m:
head = head.next
i += 1
node = head.next
while i<n:
node = node.next
i+=1
tail = node.next
node.next = None
node = head.next
head.next = tail
while node:
temp = node.next
node.next = head.next
head.next = node
node = temp
return dummy.next
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
dummy_head = ListNode(0)
node = dummy_head
while l1 and l2:
if l1.val < l2.val:
node.next = l1
l1 = l1.next
else:
node.next = l2
l2 = l2.next
node = node.next
node.next = l1 if l1 else l2
return dummy_head.next
def distribute(self, head, key):
lists = list()
for _ in range(10):
dummy_head = ListNode(None)
node = dummy_head
lists.append((dummy_head, node))
node = head.next
while node:
val = node.val // (10**key) % 10
h, n = lists[val]
n.next = node
node = node.next
n = n.next
n.next = None
lists[val] = (h, n)
return lists
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
head = ListNode(None)
pos = head
while l1 and l2:
if l1.val >= l2.val:
pos.next = l2
l2 = l2.next
else:
pos.next = l1
l1 = l1.next
pos = pos.next
if l1:
pos.next = l1
elif l2:
pos.next = l2
return head.next
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
heap = PriorityQueue()
for list_item in lists:
if list_item is not None:
heap.put(HeapItem(list_item.val, list_item))
p = result_head = ListNode(0)
while not heap.empty():
current = heap.get()
p.next = current.data
if current.data.next is not None:
heap.put(HeapItem(current.data.next.val, current.data.next))
p = p.next
p.next = None
return result_head.next
def copy_from(self, iterable):
"""
Copies content from given iterable
Args:
iterable (iterable): iterable object from which contents are copied and put into list
"""
temp = self._head
self._size = 0
for e in iterable:
new_node = ListNode(data=e, precursor=temp)
temp.insert_successor(new_node)
temp = temp._successor
self._size += 1
temp._successor = self._tail
self._tail._precursor = temp
def insertionSortList(self, head: ListNode) -> ListNode:
head_n = ListNode(float("-inf"))
while head:
n_1, n_2 = head_n, head_n.next
while n_2:
if head.val<n_2.val:
n_1.next = head
head = head.next
n_1.next.next = n_2
break
else:
n_1 = n_2
n_2 = n_2.next
else:
n_1.next = head
head = head.next
n_1.next.next = None
return head_n.next
if a is b:
found = True
break
# distance from head to loop head is the same as meeting piont to loop head
# find the loop head by moving a and h
if found:
h = head
while h is not a:
a = a.next
h = h.next
return h
return None
else:
return None
t = ListNode(3)
t.next = ListNode(2)
t.next.next = ListNode(0)
t.next.next.next = ListNode(-4)
t.next.next.next.next = t.next
#t = ListNode(1)
#t.next = ListNode(2)
#t.next.next = t
sol = Solution()
print sol.detectCycle(t).val
