def get_middle_node(self, head):
if head is None:
return None
dummy = ListNode(-1)
dummy.next = head
slow_ptr = dummy
fast_ptr = dummy
while fast_ptr and fast_ptr.next:
fast_ptr = fast_ptr.next.next
slow_ptr = slow_ptr.next
return slow_ptr
def middleNode(self, head):
# write your code here
if head is None:
return None
dummy = ListNode(-1)
dummy.next = head
slow_ptr = dummy
fast_ptr = dummy
while fast_ptr and fast_ptr.next:
fast_ptr = fast_ptr.next.next
slow_ptr = slow_ptr.next
return slow_ptr
def insertNode(self, head: ListNode, val):
if head is None:
return ListNode(val)
# write your code here
dummy = ListNode(0, head)
prev_ptr = dummy
next_ptr = head
while not (next_ptr is None or next_ptr.val > val):
prev_ptr = next_ptr
next_ptr = next_ptr.next
curr_ptr = ListNode(val)
prev_ptr.next = curr_ptr
curr_ptr.next = next_ptr
return dummy.next
def reverseBetween(self, head, m, n):
# write your code here
dummy = ListNode(-1, head)
m_prev = self.take_k_step(head=dummy, k=m - 1)
n_next = self.take_k_step(head=dummy, k=n + 1)
prev = n_next
curr = m_prev.next
for i in range(n-m + 1):
_next = curr.next
curr.next = prev
prev = curr
curr = _next
m_prev.next = prev
return dummy.next
def swapPairs(self, head):
# write your code here
if head is None or head.next is None:
return head
dummy = ListNode("dummy", head)
prev = dummy
while prev.next and prev.next.next:
curr_1 = prev.next
curr_2 = curr_1.next
next_p = curr_2.next
prev.next = curr_2
curr_2.next = curr_1
curr_1.next = next_p
prev = prev.next.next
return dummy.next
def removeDuplicates(self, head):
# write your code here
dummy = ListNode(-1, head)
prev = dummy
curr = head
have_seen = set()
while curr is not None:
if curr.val not in have_seen:
have_seen.add(curr.val)
prev = curr
curr = curr.next
else:
next_ptr = curr.next
prev.next = next_ptr
curr = next_ptr
return dummy.next
def swapNodes(self, head, v1, v2):
dummy = ListNode("dummy", head)
prev1, prev2 = self.find_previous(dummy, v1, v2)
if prev1 is None or prev2 is None:
return dummy.next
if prev1 == prev2:
return dummy.next
if prev1.next == prev2:
self.swap_adjacent(prev1)
elif prev2.next == prev1:
self.swap_adjacent(prev2)
else:
self.swap_remote(prev1, prev2)
return dummy.next
def deleteDuplicates(self, head):
# write your code here
dummy = ListNode(-1, head)
prev = dummy
while prev.next and prev.next.next:
if prev.next.val != prev.next.next.val:
prev = prev.next
else:
# for example, if we have dummy -> 1 -> 2 -> 2 -> 2 -> 3
# after this while loop we will have dummy -> 1 -> 2 -> 3, prev is point to '1'
# but we still need to delete the last occourance of '2'
while prev.next and prev.next.next and prev.next.val == prev.next.next.val:
prev.next = prev.next.next
# still need to delete prev.next
if prev.next is not None:
prev.next = prev.next.next
return dummy.next
def removeNthFromEnd(self, head, n):
# write your code here
# if the length of linked list is 'n'.
# we first set the fast and slow at dummy. so we need to let fast pointer move "n+1" step in advance.
# so if we do this, when fast pointer is at the end(fast pointer=None), the slow pointer will point to the
# previous node of the node we try to remove
dummy = ListNode("dummy", head)
fast = slow = dummy
for i in range(n + 1):
fast = fast.next
while fast is not None:
fast = fast.next
slow = slow.next
prev = slow
curr = slow.next
prev.next = curr.next
return dummy.next
def removeElements(self, head, val):
# write your code here
if head is None:
return None
if head.next is None:
if head.val == val:
return None
else:
return head
dummy = ListNode(-1, next=head)
prev_node = dummy
curr_node = head
while curr_node is not None:
if curr_node.val == val:
next_node = curr_node.next
prev_node.next = next_node
curr_node = prev_node # because the current node has been deleted, need to set curr_node
prev_node = curr_node
curr_node = curr_node.next
return dummy.next
def mergeTwoLists(self, l1, l2):
# write your code here
dummy = ListNode("dummy")
curr_merged = dummy
curr_1 = l1
curr_2 = l2
while curr_1 and curr_2:
if curr_1.val < curr_2.val:
curr_merged.next = curr_1
curr_1 = curr_1.next
else:
curr_merged.next = curr_2
curr_2 = curr_2.next
curr_merged = curr_merged.next
if curr_1 is None:
curr_merged.next = curr_2
else:
curr_merged.next = curr_1
return dummy.next