def mergeTwoLists(self, l1, l2):
if l1 is None:
return l2
if l2 is None:
return l1
if l1.val <= l2.val:
l = ListNode(l1.val)
l1 = l1.next
else:
l = ListNode(l2.val)
l2 = l2.next
ans = l
while l1 is not None and l2 is not None:
if l1.val <= l2.val:
l.next = ListNode(l1.val)
l = l.next
l1 = l1.next
else:
l.next = ListNode(l2.val)
l = l.next
l2 = l2.next
if l1 is not None:
l.next = l1
else:
l.next = l2
return ans
def swapPairs(self, head):
"""
My Method
算法：倒插
思路：
本题思路比较直观，就是新建一个dummy，然后给原链表也建一个头节点，每两个结点倒插
到新的dummy后，如果出现落单的那直接在尾部插入其即可，说明一定是最后一个结点了，
9=2*4+1，8=2*4
要注意的是每次倒插完之后要将p.next 置None，断掉尾部节点与原链表之间的关系
复杂度分析：
时间：ON，遍历一遍链表
空间：O1，常数级
"""
if head == None or head.next == None:
return head
dummy = ListNode(0)
p = dummy
dummy_head = ListNode(0)
dummy_head.next = head
while dummy_head.next != None:
if dummy_head.next.next != None:
p.next = dummy_head.next.next
tmp = dummy_head.next
dummy_head.next = dummy_head.next.next.next
p = p.next
p.next = tmp
else:
p.next = dummy_head.next
dummy_head.next = None
p = p.next
p.next = None
return dummy.next
def more_than_2_groups_test(self):
node1 = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(3)
node4 = ListNode(4)
node5 = ListNode(5)
node6 = ListNode(6)
node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5
node5.next = node6
k = 3
expectedNode1 = ListNode(3)
expectedNode2 = ListNode(2)
expectedNode3 = ListNode(1)
expectedNode4 = ListNode(6)
expectedNode5 = ListNode(5)
expectedNode6 = ListNode(4)
expectedNode1.next = expectedNode2
expectedNode2.next = expectedNode3
expectedNode3.next = expectedNode4
expectedNode4.next = expectedNode5
expectedNode5.next = expectedNode6
solution = Solution()
actualResult = solution.swapInKGruop(node1, k)
self.assertTrue(expectedNode1.equalTo(actualResult))
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
if l1 is None:
return l2
if l2 is None:
return l1
newhead = ListNode(-1, None)
returnhead = newhead
while l1 and l2:
if l1.val < l2.val:
newhead.next = l1
l1 = l1.next
else:
newhead.next = l2
l2 = l2.next
newhead = newhead.next
if l1:
newhead.next = l1
if l2:
newhead.next = l2
return returnhead.next
def test2():
n1a = ListNode(1)
n1b = ListNode(1)
n1c = ListNode(1)
n1a.next = n1b
n1b.next = n1c
rslt = removeElement(n1a, 1)
print(ListNode.print_ll(rslt))
def generate_test_list3():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n1.next = n2
n2.next = n3
return n1
def generate_test_list3():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n1.next = n2
n2.next = n3
return n1
def test2():
n1a = ListNode(1)
n1b = ListNode(1)
n1c = ListNode(1)
n1a.next = n1b
n1b.next = n1c
rslt = removeElement(n1a, 1)
print(ListNode.print_ll(rslt))
def __reverse(self, head: ListNode) -> ListNode:
dummy = ListNode(0)
dummy.next = head
ptr = head
while ptr and ptr.next:
tmp = ptr.next
ptr.next = tmp.next
tmp.next = dummy.next
dummy.next = tmp
return dummy.next
def twoSimpoleList_test(self):
l1node1 = ListNode(1)
l1node2 = ListNode(2)
l1node3 = ListNode(4)
l1node1.next = l1node2
l1node2.next = l1node3
l2node1 = ListNode(1)
l2node2 = ListNode(3)
l2node3 = ListNode(4)
l2node1.next = l2node2
l2node2.next = l2node3
resultNode1 = ListNode(1)
resultNode2 = ListNode(1)
resultNode3 = ListNode(2)
resultNode4 = ListNode(3)
resultNode5 = ListNode(4)
resultNode6 = ListNode(4)
resultNode1.next = resultNode2
resultNode2.next = resultNode3
resultNode3.next = resultNode4
resultNode4.next = resultNode5
resultNode5.next = resultNode6
solution = Solution()
result = solution.mergeTwoLists(l1node1, l2node1)
compareResult = resultNode1.equalTo(result)
self.assertTrue(compareResult)
def test2():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n1.next = n2
n2.next = n3
n3.next = n4
print(findCycleNode(n1))
def mergeTwoLists(l1: ListNode, l2: ListNode) -> ListNode:
if not l1:
return l2
elif not l2:
return l1
elif l1.val <= l2.val:
l1.next = mergeTwoLists(l1.next, l2)
return l1
else:
l2.next = mergeTwoLists(l1, l2.next)
return l2
def test2():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n1.next = n2
n2.next = n3
n3.next = n4
ListNode.print_ll(reorderList(n1))
def test2():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n1.next = n2
n2.next = n3
n3.next = n4
print(findCycleNode(n1))
def test2():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n1.next = n2
n2.next = n3
n3.next = n4
ListNode.print_ll(reorderList(n1))
def test3():
n6 = ListNode(6)
n7 = ListNode(7)
n9 = ListNode(9)
n5 = ListNode(5)
n6.next = n7
n7.next = n9
ListNode.print_ll(addTwoNumbers(n6, n5, 0))
ListNode.print_ll(addTwoNumbersNoCarry(n6, n5))
def mergeTwoLists1(self, l1: ListNode, l2: ListNode) -> ListNode:
# end case : l1 or l2 is None
if not l1 or not l2:
return l1 or l2
# base case : compare l1.val and l2.val, the smaller one such as l1 will recursively be invoked with the arguments of l1.next and l2
if l1.val < l2.val:
l1.next = self.mergeTwoLists1(l1.next, l2)
return l1
else:
l2.next = self.mergeTwoLists1(l1, l2.next)
return l2
def test3():
n6 = ListNode(6)
n7 = ListNode(7)
n9 = ListNode(9)
n5 = ListNode(5)
n6.next = n7
n7.next = n9
ListNode.print_ll(addTwoNumbers(n6, n5, 0))
ListNode.print_ll(addTwoNumbersNoCarry(n6, n5))
def test2():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n3.next = n2
n2.next = n1
h = n3
rslt = mergeSort(h)
ListNode.print_ll(rslt)
def _reverseList(self, head):
if head == None or head.next == None: return head
newhead = ListNode(0)
newhead.next = head
current_node = head
next_node = head.next
while (next_node != None):
current_node.next = next_node.next
next_node.next = newhead.next
newhead.next = next_node
next_node = current_node.next
return newhead.next
def getList():
l1 = ListNode(1)
l2 = ListNode(3)
l3 = ListNode(6)
l4 = ListNode(2)
l5 = ListNode(7)
l6 = ListNode(8)
l1.next = l2
l2.next = l3
l4.next = l5
l5.next = l6
return l1, l4
def test2():
n1 = ListNode(1)
n1a = ListNode(1)
n1b = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n1.next = n1a
n1a.next = n1b
n1b.next = n2
n2.next = n3
ListNode.print_ll(removeDupComp(n1))
def test3():
n1 = ListNode(1)
n1a = ListNode(1)
n1b = ListNode(1)
n2a = ListNode(2)
n2b = ListNode(2)
n1.next = n1a
n1a.next = n1b
n1b.next = n2a
n2a.next = n2b
ListNode.print_ll(removeDupComp(n1))
def generate_test_list1():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
return n1
def test1():
n0 = ListNode(0)
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n0.next = n1
n1.next = n2
n2.next = n3
n3.next = n4
ListNode.print_ll(reorderList(n0))
def test2():
n1 = ListNode(1)
n1a = ListNode(1)
n1b = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n1.next = n1a
n1a.next = n1b
n1b.next = n2
n2.next = n3
ListNode.print_ll(removeDupComp(n1))
def test1():
n0 = ListNode(0)
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n0.next = n1
n1.next = n2
n2.next = n3
n3.next = n4
ListNode.print_ll(reorderList(n0))
def test3():
n1 = ListNode(1)
n1a = ListNode(1)
n1b = ListNode(1)
n2a = ListNode(2)
n2b = ListNode(2)
n1.next = n1a
n1a.next = n1b
n1b.next = n2a
n2a.next = n2b
ListNode.print_ll(removeDupComp(n1))
def generate_test_list1():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
return n1
def swapPairs(self, head: ListNode) -> ListNode:
new_head = head
if head.next:
new_head = head.next
head.next = new_head.next
new_head.next = head
while head.next and head.next.next:
temp = head.next
temp2 = head.next.next.next
head.next = head.next.next
head.next.next = temp
temp.next = temp2
head = temp
return new_head
def example_k_is_3_test(self):
node1 = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(3)
node4 = ListNode(4)
node5 = ListNode(5)
node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5
k = 3
expectedNode1 = ListNode(3)
expectedNode2 = ListNode(2)
expectedNode3 = ListNode(1)
expectedNode4 = ListNode(4)
expectedNode5 = ListNode(5)
expectedNode1.next = expectedNode2
expectedNode2.next = expectedNode3
expectedNode3.next = expectedNode4
expectedNode4.next = expectedNode5
solution = Solution()
actualResult = solution.swapInKGruop(node1, k)
self.assertTrue(expectedNode1.equalTo(actualResult))
def partition(self, head, x):
"""
:type head: ListNode
:type x: int
:rtype: ListNode
"""
if not head:
return head
# maintain the tail of sub-list with (nodes <= target)
tail = ListNode(0)
tail.next = head
dummy = tail # record it
currentPrev = tail
current = head
# two operation: 1. cut smaller node; 2. insert to sublist
while current:
'''
@note:@memorize:
下面的反人类解法我也给自己跪了，找到比x小的，插入。
一直维护小于x的sublist的tail，被main里的测试fail
其实，维护大于等于x的sublit的head，要更加简单，符合人类思维。。。
'''
if current.val < x: # update tail pointer, but do nothing
# 1. cut
currentPrev.next = current.next
currentForNextLoop = current.next # record it first
# 2. insert
tmp = tail.next
tail.next = current
current.next = tmp
tail = current # update smaller-node-list tail
current = currentForNextLoop # for next loop
# @note: here, no update for currentPrev, still the same one
else:
currentPrev = current
current = current.next
return dummy.next
def test4():
l1 = ListNode(1)
l2 = ListNode(2)
l3 = ListNode(3)
l4 = ListNode(4)
l5 = ListNode(5)
l1.next = l2
l2.next = l3
l3.next = l4
l4.next = l5
ListNode.print_ll(l1)
ListNode.print_ll(removeNtoLast(l1, 2))
def test3():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n6 = ListNode(6)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = n6
ListNode.print_ll(revKGrp(n1, 4))
def test3():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n6 = ListNode(6)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = n6
ListNode.print_ll(revKGrp(n1, 4))
def odd_length_test(self):
node1 = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(3)
node1.next = node2
node2.next = node3
resultNode1 = ListNode(2)
resultNode2 = ListNode(1)
resultNode3 = ListNode(3)
resultNode1.next = resultNode2
resultNode2.next = resultNode3
solution = Solution()
actualResult = solution.swapPairs(node1)
self.assertTrue(resultNode1.equalTo(actualResult))
def test1():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n6 = ListNode(6)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = n6
#ListNode.print_ll(revKGrp(n1, 2))
ListNode.print_ll(revKGroup_r(n1, 1))
def rotateRight(self, head: ListNode, k: int) -> ListNode:
if not head:
return None
sentinel = ListNode(0, head)
l = 1
while head.next:
l += 1
head = head.next
k = k % l
head.next = sentinel.next
for i in range(l - k):
head = head.next
sentinel.next = head.next
head.next = None
return sentinel.next
def test1():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n6 = ListNode(6)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = n6
#ListNode.print_ll(revKGrp(n1, 2))
ListNode.print_ll(revKGroup_r(n1, 1))
def test2():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n6 = ListNode(6)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = n6
ListNode.print_ll(n1)
ListNode.print_ll(rotateLSegment(n1, 1, 4))
def reverseLinkedListII(head, m, n):
if head == None:
return None
dummy = ListNode(0)
dummy.next = head
head = dummy
# find premmNode and mNode
for i in range(1, m):
head = head.next
prevmNode = head
mNode = head.next
# reverse link from m to n
nNode = mNode
nextnNode = nNode.next
for i in range(m, n):
temp = nextnNode.next
nextnNode.next = nNode
nNode = nextnNode
nextnNode = temp
# combine
prevmNode.next = nNode
mNode.next = nextnNode
return dummy.next
def test3():
n1 = ListNode(1)
n2 = ListNode(2)
n1.next = n2
ListNode.print_ll(reorderList(n1))
def deleteDuplicates(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if not head:
return head
# a dummy node is must
dummy = ListNode(0)
dummy.next = head
prev = dummy
current = head
while current:
if current.next and current.val == current.next.val:
# find duplciate, delete all
while current.next and current.val == current.next.val:
current = current.next
# now current pointer is at last node of duplicated
# delete duplicated nodes
prev.next = current.next
current = current.next
# @note: prev stays the same
else:
prev = current
current = current.next
return dummy.next # return could be a empty list, if input list with all duplicates
def revKGroup_r(h, k):
count = 0
dummy = ListNode(-1)
dummy.next = h
n = dummy
head = dummy
while head:
tail = head.next
n = tail
while n and count < k:
n = n.next
count += 1
if count < k and not n:
break
count = 0
stopN = n
head.next = revK_r(tail, stopN)
tail.next = stopN
head = tail
return dummy.next
def oddEvenList(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if not head:
return
dummy1, dummy2 = ListNode(0), ListNode(0)
dummy1.next = head
dummy2.next = head.next
dummy3 = head.next
count = 3
while head and dummy3 and dummy3.next and head.next:
if head.next.next and not dummy3.next.next:
head.next = head.next.next
head = head.next
break
elif not head.next.next and dummy3.next.next:
dummy3.next = dummy3.next.next
dummy3 = dummy3.next
break
if count%2:
head.next = head.next.next
head = head.next
else:
dummy3.next = dummy3.next.next
dummy3 = dummy3.next
head.next = dummy2.next
if dummy3:
dummy3.next = None
return dummy1.next
def generate_test_list2():
n1 = ListNode(1)
n2 = ListNode(2)
n1.next = n2
return n1
def revKGroup_r(h, k):
count = 0
dummy = ListNode(-1)
dummy.next = h
n = dummy
head = dummy
while head:
tail = head.next
n = tail
while n and count < k:
n = n.next
count += 1
if count < k and not n:
break
count = 0
stopN = n
head.next = revK_r(tail, stopN)
tail.next = stopN
head = tail
return dummy.next
def test3():
n1 = ListNode(1)
n2 = ListNode(2)
n1.next = n2
ListNode.print_ll(reorderList(n1))
def rotateLSegment(l, m, n):
dummyN = ListNode(0)
dummyN.next = l
l = dummyN
rslt, i = l, 0
while i < m-1:
l = l.next
i += 1
t, i = None, 0
beg, end = l, l.next
l = l.next
while l and i <= n-m:
h = l
l = l.next
h.next = t
t = h
i += 1
beg.next = t
end.next = l
return dummyN.next
def test1():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n6 = ListNode(6)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = n6
ListNode.print_ll(n1)
ListNode.print_ll(swapPairs(n1))
print('--------------')
def test1():
n2 = ListNode(2)
n4a = ListNode(4)
n3 = ListNode(3)
n5 = ListNode(5)
n6 = ListNode(6)
n4b = ListNode(4)
n2.next = n4a
n4a.next = n3
n5.next = n6
n6.next = n4b
ListNode.print_ll(addTwoNumbers(n2, n5, 0))
ListNode.print_ll(addTwoNumbersNoCarry(n2, n5))
def test6():
n6 = ListNode(6)
n7 = ListNode(7)
n9 = ListNode(9)
n5 = ListNode(5)
n8 = ListNode(8)
n4 = ListNode(4)
n6.next = n7
n7.next = n9
n5.next = n8
n8.next = n4
ListNode.print_ll(addTwoNumbers(n6, n5, 0))
ListNode.print_ll(addTwoNumbersNoCarry(n6, n5))
def test1():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n6 = ListNode(6)
n6.next = n5
n5.next = n4
n4.next = n3
n3.next = n2
n2.next = n1
h = n6
rslt = mergeSort(h)
ListNode.print_ll(rslt)
def test1():
n9 = ListNode(9)
n4 = ListNode(4)
n5 = ListNode(5)
n1 = ListNode(1)
n9.next = n4
n4.next = n5
n5.next = n1
n8 = ListNode(8)
n7 = ListNode(7)
n2 = ListNode(2)
n8.next = n7
n7.next = n2
res = addTwoNums(n9, n8)
ListNode.print_ll(res)
def test1():
n1 = ListNode(1)
n3 = ListNode(3)
n2 = ListNode(2)
n4 = ListNode(4)
n14 = ListNode(14)
n18 = ListNode(18)
n7 = ListNode(7)
n9 = ListNode(9)
n11 = ListNode(11)
n13 = ListNode(13)
n1.next = n3
l1 = n1
n2.next = n4
n4.next = n14
n14.next = n18
l2 = n2
n7.next = n9
n9.next = n11
n11.next = n13
l3 = n7
lists = [l1, l2, l3]
rslt = mergeKLL(lists)
ListNode.print_ll(rslt)
def test3():
n1 = ListNode(1)
n2 = ListNode(2)
n2.next = n1
h = n2
rslt = mergeSort(h)
ListNode.print_ll(rslt)
def addNumbers(h1, h2):
l1, l2 = getLeng(h1), getLeng(h2)
needToAdd1 = addNumRecur(h1, h2, l1 >= l2, abs(l1-l2))
if needToAdd1:
newN = ListNode(1)
newN.next = (h1 if l1>=l2 else h2)
return newN
else:
return (h1 if l1>=l2 else h2)
