from typing import List
from util import ListNode, lc_list2singlelinkedlist, lc_singlelinkedlist2list
class Solution:
def deleteDuplicates(self, head: ListNode) -> ListNode:
rtn = head
while head:
if head.next and head.val == head.next.val:
nxt = head.next
head.next = head.next.next
del nxt
else:
head = head.next
return rtn
if __name__ == "__main__":
sol = Solution()
test_cases = [
[1, 1, 2, 3, 3],
[1, 1, 1, 2, 2, 3],
]
for i in test_cases:
i = lc_list2singlelinkedlist(i)
result = sol.deleteDuplicates(i)
print(lc_singlelinkedlist2list(result))
class Solution:
def insertionSortList(self,
head: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode(-5001)
dummy.next = to_insert = head
while head and head.next:
if head.val > head.next.val:
to_insert = head.next
pre = dummy
while pre.next.val < to_insert.val:
pre = pre.next
head.next = to_insert.next
to_insert.next = pre.next
pre.next = to_insert
else:
head = head.next
return dummy.next
if __name__ == "__main__":
sol = Solution()
test_cases = [
[4, 2, 1, 3],
[-1, 5, 3, 4, 0],
]
for i in test_cases:
dummyult = sol.insertionSortList(lc_list2singlelinkedlist(i))
print(lc_singlelinkedlist2list(dummyult))
if not head:
return None
tail = head
n = 1
while tail.next:
tail = tail.next
n += 1
mod = k % n
if mod == 0:
return head
pt = head
for i in range(n - mod - 1):
pt = pt.next
rtn = pt.next
pt.next = None
tail.next = head
return rtn
if __name__ == "__main__":
sol = Solution()
test_cases = [
[[1, 2, 3, 4, 5], 2],
[[1, 2, 3, 4, 5, 6], 2],
[[1, 2, 3, 4, 5, 6], 12],
[[1, 2, 3], 4],
]
for i, j in test_cases:
result = (sol.rotateRight(lc_list2singlelinkedlist(i), j))
print(lc_singlelinkedlist2list(result))
return None
sp = ListNode()
sp.next = head
pt = head
pre = sp
while pt and pt.next:
if pt.val == pt.next.val:
while pt.next and pt.val == pt.next.val:
pt.next = pt.next.next
pre.next = pt.next
pt = pre.next
else:
pre = pt
pt = pt.next
return sp.next
if __name__ == "__main__":
sol = Solution()
test_cases = [
[],
[1, 2, 3, 3, 4, 4, 5],
[0, 0, 1, 1, 1, 1, 2, 3, 3],
[1, 1, 1, 2, 3],
]
for i in test_cases:
result = sol.deleteDuplicates(lc_list2singlelinkedlist(i))
print(lc_singlelinkedlist2list(result))
start = head
head = head.next
cnt += 1
pre = None
while head and cnt != right:
nxt = head.next
head.next = pre
pre = head
head = nxt
cnt += 1
if head:
start.next.next = head.next
head.next = pre
start.next = head
return rtn.next
if __name__ == "__main__":
sol = Solution()
test_cases = [
[[3, 5], 1, 1],
[[1, 2, 3, 4, 5], 2, 4],
[[5], 1, 1],
]
for i, j, k in test_cases:
result = sol.reverseBetween(lc_list2singlelinkedlist(i), j, k)
print(lc_singlelinkedlist2list(result))
class Solution:
def sortedListToBST(self, head: ListNode) -> TreeNode:
if not head:
return None
slow, fast = head, head
pre = None
while fast and fast.next:
pre = slow
slow = slow.next
fast = fast.next.next
if pre:
pre.next = None
rtn = TreeNode(slow.val)
rtn.left = self.sortedListToBST(head) if head != slow else None
rtn.right = self.sortedListToBST(slow.next)
return rtn
if __name__ == "__main__":
sol = Solution()
test_cases = [
[-10, -3, 0, 5, 9, 12],
[-10, -3, 0, 5, 9],
]
for i in test_cases:
result = sol.sortedListToBST(lc_list2singlelinkedlist(i))
print(lc_tree2list(result))
pt = head
pre = dict()
cnt = 1
while pt.next:
pre[pt.next] = pt
pt = pt.next
cnt += 1
# now pt is the last node
# print(cnt)
pt2 = head
cnt = (cnt + 1) // 2
while cnt > 1:
pt.next = pt2.next
pt2.next = pt
pt2 = pt.next
pt = pre[pt]
cnt -= 1
pt.next = None
print(lc_singlelinkedlist2list(head))
if __name__ == "__main__":
sol = Solution()
test_cases = [
[1],
[1, 2, 3, 4],
[1, 2, 3, 4, 5]
]
for i in test_cases:
sol.reorderList(lc_list2singlelinkedlist(i))
class Solution:
def getIntersectionNode(self, headA: ListNode,
headB: ListNode) -> ListNode:
a = set()
while headA:
a.add(headA)
headA = headA.next
while headB:
if headB in a:
return headB
headB = headB.next
return None
if __name__ == "__main__":
sol = Solution()
headA = [4, 1, 8, 4, 5]
headB = [5, 6, 1, 8, 4, 5]
headA = lc_list2singlelinkedlist(headA)
headB = lc_list2singlelinkedlist(headB)
tmpA = headA
while tmpA.val != 8:
tmpA = tmpA.next
tmpB = headB
while tmpB.val != 1:
tmpB = tmpB.next
tmpB.next = tmpA
print(sol.getIntersectionNode(headA, headB))
class Solution:
def partition(self, head: ListNode, x: int) -> ListNode:
s_pt = s_cur = ListNode()
l_pt = l_cur = ListNode()
while head:
tmp = head.next
if head.val < x:
s_cur.next = head
s_cur = s_cur.next
else:
l_cur.next = head
l_cur = l_cur.next
head.next = None
head = tmp
s_cur.next = l_pt.next
return s_pt.next
if __name__ == "__main__":
sol = Solution()
test_cases = [
[[1, 4, 3, 2, 5, 2], 3],
[[1, 4, 3, 2, 5, 2], 4],
]
for i, j in test_cases:
result = sol.partition(lc_list2singlelinkedlist(i), j)
print(lc_singlelinkedlist2list(result))
import bisect
import math
from typing import List
from collections import deque, defaultdict, OrderedDict
from util import (
TreeNode, lc_list2tree,
ListNode, lc_list2singlelinkedlist
)
class Solution:
def middleNode(self, head: ListNode) -> ListNode:
l = []
while head:
l.append(head)
head = head.next
return l[len(l) // 2]
if __name__ == "__main__":
sol = Solution()
l = [1,2,3,4,5,6]
l = [1,2,3,4,5]
l = lc_list2singlelinkedlist(l)
print(sol.middleNode(l))
