def merge_sort(left, right):
if left == None:
return right
if right == None:
return left
dummy = ListNode(0)
p = dummy
while left and right:
if left.val <= right.val:
p.next = left
left = left.next
else:
p.next = right
right = right.next
p = p.next
if left != None:
p.next = left
if right != None:
p.next = right
return dummy.next
def swapPairs(self, head: ListNode) -> ListNode:
if head is None:
return None
dummy_head = ListNode(-1)
dummy_head.next = head
p1, p2, p3 = dummy_head, head, head.next
while p2 is not None and p3 is not None:
p2.next = p3.next
p3.next = p2
p1.next = p3
p1 = p2
p2 = p2.next
if p2 is None:
break
p3 = p2.next
return dummy_head.next
def deleteDuplicates(self, head):
# write your code here
if head is None:
return head
prehead = ListNode(head.val - 1)
prehead.next = head
node = prehead
while node.next and node.next.next:
if node.next.val == node.next.next.val:
v = node.next.val
tnode = node.next
while tnode:
if tnode.val == v:
tnode = tnode.next
else:
break
node.next = tnode
else:
node = node.next
return prehead.next
def josephus(n, m):
# create circular list with n elements
for i in range(n):
if i == 0:
firstNode = ListNode(i)
circle = CircularList(firstNode)
last = firstNode
else:
last = circle.insertAfter(i, last)
#start deleting every m-th item
counter = n
current = circle.lst
while counter != 1:
for j in range(m - 2):
current = current.ptr
circle.removeAfter(current)
current = current.ptr
counter -= 1
return current.info
def linkedListCycleII(head):
if head == None or head.next == None:
return None
dummy = ListNode(0)
dummy.next = head
slow = head
fast = head.next
head = dummy
while slow != fast:
if fast == None or fast.next == None:
return None
slow = slow.next
fast = fast.next.next
while slow != head:
slow = slow.next
head = head.next
return head.val
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 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 removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
if head is None or n < 0:
return None
dummy_head = ListNode(-1)
dummy_head.next = head
node1 = dummy_head
node2 = dummy_head
for i in range(n):
node1 = node1.next
if node1 is None:
return None
while node1.next is not None:
node1 = node1.next
node2 = node2.next
node2.next = node2.next.next
return dummy_head.next
def removeDupComp(head):
"""
Got this first try. 96.2% - 39.0% performance
"""
if not head: return None
dummy = ListNode(head.val - 1)
dummy.next = head
i, j = dummy, dummy.next
while j:
if i.next == j:
j = j.next
elif i.next.val == j.val:
while j and i.next.val == j.val:
j = j.next
i.next = j
else:
i = i.next
j = j.next
return dummy.next
def reorderList(self, head: ListNode) -> None:
"""
Do not return anything, modify head in-place instead.
"""
dummy = ListNode(0)
dummy.next = head
fast = slow = dummy
while fast and fast.next:
slow = slow.next
fast = fast.next.next
ReverseHead = self.__reverse(slow.next)
slow.next = None
ptr1 = head
ptr2 = ReverseHead
while ptr1 and ptr2:
tmp1 = ptr1.next
tmp2 = ptr2.next
ptr1.next = ptr2
ptr2.next = tmp1
ptr1 = tmp1
ptr2 = tmp2
def insertionSortList(self, head):
if not head:
return head
curr = head.next
last = head
p = ListNode(0)
pre = p
pre.next = head
while curr:
next_node = curr.next
if curr.val < last.val:
last.next = curr.next
while pre.next and pre.next.val <= curr.val:
pre = pre.next
curr.next = pre.next
pre.next = curr
pre = p
else:
last = last.next
curr = next_node
return pre.next
def merge_two_lists_rec(l1, l2):
l3 = ListNode(0)
n3 = l3
def recurse(n1, n2, n3):
if not n1 and not n2:
return
elif not n1:
n3.next = n2
return
elif not n2:
n3.next = n1
return
if n1.val <= n2.val:
n3.next = n1
recurse(n1.next, n2, n3.next)
else:
n3.next = n2
recurse(n1, n2.next, n3.next)
recurse(l1, l2, n3)
return l3.next
def swapPairs0(self, head):
"""
do as they say
按照人家的要求来
"""
if head == None or head.next == None:
return head
dummy = ListNode(0)
p = dummy
dummy.next = head
while p and p.next and p.next.next:
first = p.next
second = p.next.next
third = p.next.next.next
p.next = second
second.next = first
first.next = third
p = first
return dummy.next
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
if len(lists) == 0:
return None
ListNode.__lt__ = less_than
heap = []
head = dum = ListNode(0)
for i in range(len(lists)):
if lists[i] != None:
pq.heappush(heap, lists[i])
while len(heap) > 0:
poped_node = pq.heappop(heap)
if poped_node.next != None:
pq.heappush(heap, poped_node.next)
head.next = poped_node
head = head.next
return dum.next
def test2():
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n6 = ListNode(6)
n7 = ListNode(7)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = n6
n6.next = n7
ListNode.print_ll(n1)
ListNode.print_ll(swapPairs(n1))
print('--------------')
def removeElements(self, head, val):
"""
算法：dummy节点
思路：
设置dummy节点，head节点向后遍历，如果找到==val的head就删除，否则的话指针向后挪
复杂度分析：
时间：ON
空间：O1
"""
dummy = ListNode(0)
dummy.next = head
pre = dummy
while head:
if head.val == val:
pre.next = head.next
head = pre.next
else:
head = head.next
pre = pre.next
return dummy.next
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
if m == n:
return head
dummy = ListNode(-1)
dummy.next = head
pre, cur = None, dummy
for _ in range(m):
pre, cur = cur, cur.next
pos = pre
pre, cur = cur, cur.next
for _ in range(m, n):
cur.next, pre, cur = pre, cur, cur.next
pos.next.next = cur
pos.next = pre
return dummy.next
def swapPairs(self, head: ListNode) -> ListNode:
if not head or not head.next:
return head
c = h = ListNode(0, head)
head = head.next
while c:
c = c.next
if not c:
break
c = c.next
if not c:
break
h.next.next = c.next
c.next = h.next
h.next = c
h = c = c.next
return head
def test1():
l1 = ListNode(1)
l2 = ListNode(2)
l3 = ListNode(3)
l4 = ListNode(4)
l5 = ListNode(5)
l6 = ListNode(6)
l1.next = l3
l3.next = l5
l2.next = l4
l4.next = l6
print_ll(l1)
print_ll(l2)
print_ll(mergeList_r(l1, l2))
def test2():
l1 = ListNode(1)
l2 = ListNode(2)
l3 = ListNode(3)
l4 = ListNode(4)
l5 = ListNode(5)
l6 = ListNode(6)
l1.next = l2
l2.next = l3
l4.next = l5
l5.next = l6
print_ll(l1)
print_ll(l4)
print_ll(mtl_rec(l1, l4))
def test1():
n1 = ListNode(1)
n4 = ListNode(4)
n3 = ListNode(3)
n2a = ListNode(2)
n5 = ListNode(5)
n2b = ListNode(2)
n1.next = n4
n4.next = n3
n3.next = n2a
n2a.next = n5
n5.next = n2b
ListNode.print_ll(n1)
ListNode.print_ll(partitionList(n1, 3))
def sortList2(self, head):
"""
Disscussion QuickSort
算法：快排
思路：
快排的链表写法，要注意一些dummy节点的运用，以及记录pre和post等
复杂度分析：
时间：NLOGN
空间：01，不考虑递归栈的话
"""
def partition(start, end):
node = start.next.next
pivotPrev = start.next
pivotPrev.next = end
pivotPost = pivotPrev
while node != end:
temp = node.next
if node.val > pivotPrev.val:
node.next = pivotPost.next
pivotPost.next = node
elif node.val < pivotPrev.val:
node.next = start.next
start.next = node
else:
node.next = pivotPost.next
pivotPost.next = node
pivotPost = pivotPost.next
node = temp
return [pivotPrev, pivotPost]
def quicksort(start, end):
if start.next != end:
prev, post = partition(start, end)
quicksort(start, prev)
quicksort(post, end)
newHead = ListNode(0)
newHead.next = head
quicksort(newHead, None)
return newHead.next
def test3():
l1 = ListNode(1)
l2 = ListNode(2)
l3 = ListNode(3)
l4 = ListNode(4)
l5 = ListNode(5)
l6 = ListNode(6)
l1.next = l2
l2.next = l3
l3.next = l4
l4.next = l5
print_ll(l1)
print_ll(l6)
print_ll(mtl_rec(l1, l6))
def mergeTwoLists(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
self.printNode(l1)
self.printNode(l2)
ans = head = ListNode(0)
index = 0
while l1 != None or l2 != None:
#print('while 圈數: index=', index, l1.val, l1.next, l2.val, l2.next)
index += 1
if l1 != None and l2 != None:
if l1.val < l2.val:
head.next = l1
l1 = l1.next
else:
head.next = l2
l2 = l2.next
continue
else:
if l1 != None:
head.next = l1
l1 = l1.next
continue
if l2 != None:
head.next = l2
l2 = l2.next
continue
# ll1 = self.nodetoList(l1)
# ll2 = self.nodetoList(l2)
# l11.extend(ll2)
self.printNode(ans.next)
return ans.next
def mergeKLL(lists):
"""
Note: algorithm is the fastest but PriorityQue is not as fast as heapq
"""
from Queue import PriorityQueue
pq = PriorityQueue()
rslt = ListNode(0)
for node in lists:
if node: pq.put((node.val, node))
head = rslt
while pq.qsize() > 0:
node = pq.get()[1]
head.next = node
head = head.next
if node.next:
pq.put((node.next.val, node.next))
return rslt.next
def deleteDuplicates(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if head == None or head.next == None:
return head
tHead = ListNode()
tmp = tHead
cur = head
while cur != None:
if cur.next == None or cur.val != cur.next.val:
tmp.next = cur
tmp = cur
else:
while cur != None and cur.next != None and cur.val == cur.next.val:
cur = cur.next
cur = cur.next
tmp.next = None
return tHead.next
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():
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 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)
