def reverseBetween(self, head, m, n):
"""
:type head: ListNode
:type m: int
:type n: int
:rtype: ListNode
"""
if not head:
return head
dummy = ListNode(-1)
dummy.next = head
left, cur = dummy, head
k = n - m + 1
while m > 1:
left = cur
cur = cur.next
m -= 1
# reserve k times
start = cur
prev = None
while k:
tmp = cur.next
cur.next = prev
prev = cur
cur = tmp
k -= 1
# connect together
left.next = prev
start.next = cur
return dummy.next
def mergeTwoLists(l1: ListNode, l2: ListNode) -> ListNode:
if not l2 or not l1:
return l1 or l2
if l1.val > l2.val:
l1, l2 = l2, l1
head = l1
while l1.next and l2:
if l2.val < l1.next.val:
next1, next2 = l1.next, l2.next
l1.next, l2.next = l2, next1
l1, l2 = l2, next2
else:
l1 = l1.next
if l2:
l1.next = l2
return head
def main():
# print("Starting")
# head1 = ListNode(1)
# head1.next = ListNode(3)
# head1.next.next = ListNode(16)
# # head1.next.next.next = ListNode(5)
# tmp = head1
# head2 = ListNode(1)
# head2.next = ListNode(1)
# head2.next.next=ListNode(9)
sol=Solution()
# head3 = sol.mergeSortedLists(head1,head2)
# tmp = head3
sample_del=ListNode(1)
sample_del.next=ListNode(1)
sample_del.next.next=ListNode(2)
sample_del.next.next.next=ListNode(3)
sample_del.next.next.next.next=ListNode(3)
sample_del.next.next.next.next.next=ListNode(4)
head4=sol.deleteDuplicates(sample_del)
tmp_del=head4
while tmp_del:
print(tmp_del.val)
tmp_del=tmp_del.next
print ("\n\n")
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
if not head:
return head
dummy = ListNode(-1) # 哑节点
dummy.next = head
if m > n:
m, n = n, m
if n > m:
p = dummy
prePm = None
for _ in range(m):
prePm = p
p = p.next
pM = p
pNext = p.next
for _ in range(n - m):
pPre = p
p = pNext
pNext = p.next
p.next = pPre
pM.next = pNext
prePm.next = p
return dummy.next
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
if not head or k == 1:
return head
dummy = ListNode(-1)
dummy.next = head
l, r = dummy, dummy
step = 0
while r:
r = r.next
if r:
step += 1
if step == k:
step = 0
# 翻转 l 和r 之间的所有节点
tmp = l.next
prev = r.next
while True:
next = tmp.next
tmp.next = prev
prev = tmp
if tmp == r:
break
tmp = next
tmp = l.next
l.next = r
l, r = tmp, tmp
return dummy.next
def merge(linked_lists):
merged = []
# We can collect all nodes in O(n) time, where n is the number of elements
for node in linked_lists:
while node:
merged.append(node.val)
node = node.next
# Sorts in O(n log n) time, which results in O(n + n log n), or just O(n log n) time complexity
sorted_list = sorted(merged)
# if the return type should be array
# just return sorted_list
# if the return type should be Node
# we need to collect all elements again but this time into a linked list of type Node
# this step adds O(n) time, but the resulting complexity still remains O (n log n)
sorted_linked_list = ListNode()
# so we still can have access to the first node
head = sorted_linked_list
for value in sorted_list:
# Node (value) points to tail, which is None
sorted_linked_list.next = ListNode(value)
sorted_linked_list = sorted_linked_list.next
# return the first node
return head.next
def reverseList(node: ListNode) -> ListNode:
h, prev = node, None
while node:
h = node
next = node.next
node.next = prev
prev = h
node = next
return h
def swapPairs(self, head: ListNode) -> ListNode:
dummy = ListNode(0)
dummy.next = head
curr = head
if not curr or not curr.next:
return head
follow = curr.next
curr.next = follow.next
follow.next = curr
dummy.next = follow
head = dummy.next
while curr.next and curr.next.next:
dummy = curr
curr = curr.next
follow = curr.next
curr.next = follow.next
follow.next = curr
dummy.next = follow
return head
def reverseList(head: ListNode) -> ListNode:
if not head.next:
return head
start = reverseList(head.next)
node = start
while node.next:
node = node.next
node.next = head
head.next = None
return start
def mergeTwoLists(self, l1, l2):
temp = ListNode(0)
head = temp
while l1 is not None and l2 is not None:
if l1.val <= l2.val:
temp.next = ListNode(l1.val)
l1 = l1.next
else:
temp.next = ListNode(l2.val)
l2 = l2.next
temp = temp.next
while l1 is not None:
temp.next = ListNode(l1.val)
l1 = l1.next
temp = temp.next
while l2 is not None:
temp.next = ListNode(l2.val)
l2 = l2.next
temp = temp.next
return head.next
def reverseList0(head: ListNode) -> ListNode:
if not head:
return
pre = head
cur = head.next
while cur:
temp = cur.next
cur.next = pre
pre = cur
cur = temp
head.next = None
return pre
def add_list_item(self, item):
if (not isinstance(item, ListNode)):
item = ListNode(item)
if (self.head is None):
self.head = item
item.next = None
item.prev = None
self.tail = item
else:
self.tail.next = item
item.prev = self.tail
self.tail = item
def deleteDuplicates(self, list_node):
if not list_node:
return list_node
head = ListNode(None)
head.next = list_node
previous_node = head
current_node = head.next
while current_node:
next_node = current_node.next
if previous_node.val == current_node.val:
self.unlink_list_node(previous_node, current_node)
else:
previous_node = current_node
current_node = next_node
return head.next
def swapPairs(self, linked_list):
if not linked_list:
return linked_list
head = ListNode(None)
head.next = linked_list
processed_node = head
while processed_node.next:
first_node = processed_node.next
second_node = first_node.next
if not second_node:
return head.next
second_node_next = second_node.next
processed_node.next = second_node
second_node.next = first_node
first_node.next = second_node_next
processed_node = first_node
return head.next
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
preHead = ListNode(0)
preHead.next = head
cur = preHead
for i in range(0, m - 1):
cur = cur.next
start = cur
cur = cur.next
end = cur
cur = cur.next
for i in range(m, n):
temp = start.next
start.next = cur
cur = cur.next
start.next.next = temp
end.next = cur
return preHead.next
def make_linked_list_cycle(self, linked_list, position):
if not linked_list or position == -1:
return linked_list
head = ListNode(None)
head.next = linked_list
current_node = head.next
target_node = None
last_node = None
index = 0
while current_node:
if index == position:
target_node = current_node
last_node = current_node
current_node = current_node.next
index += 1
if target_node:
last_node.next = target_node
return head.next
def swapPairs(self, head: ListNode) -> ListNode:
if not head or not head.next:
return head
dummyNode = ListNode(-1)
dummyNode.next = head
first, second = dummyNode, dummyNode.next.next # second 和 first 间隔一个节点
while second:
# 交换节点
tmp = first.next
first.next = second
tmp.next = second.next
second.next = tmp
second = tmp.next.next if tmp.next else None
first = tmp
return dummyNode.next
def reorderList(self, head: ListNode) -> None:
"""
Do not return anything, modify head in-place instead.
"""
if not head:
return
# 先找到列表的中间节点和列表的长度
fast = slow = head
N = 0
while fast:
fast = fast.next
N += 1
if fast:
fast = fast.next
N += 1
slow = slow.next
if N > 1:
# 此时fast指向None，slow指向中间节点，N为列表长度
# 逆序（slow，fast）之间的列表
head2 = slow.next
slow.next = None
prev = None
while head2:
next = head2.next
head2.next = prev
prev = head2
if not next:
break
head2 = next
# 合并head 和head2 两个列表
while head2:
next2 = head2.next
next = head.next
head.next = head2
head2.next = next
head = next
head2 = next2
def insertionSortList(self, head: ListNode) -> ListNode:
if not head:
return head
dummy = ListNode(-1)
dummy.next = head
last = head # 最后一个排好序的节点
cur = head.next # 待插入的节点
while cur:
if last.val <= cur.val:
last = cur
else:
prev = dummy
while prev.next.val <= cur.val:
prev = prev.next
last.next = cur.next
cur.next = prev.next
prev.next = cur
cur = last.next
return dummy.next
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
# if m == n == 1:
# return head
prev = None
curr = head
ne = curr.next
i = 1
while i < n:
if i < m:
prev = curr
curr = curr.next
ne = curr.next
i += 1
dummy = None
if not prev:
q = head
else:
q = prev.next
while q is not ne:
temp = q.next
q.next = dummy
dummy = q
q = temp
if not prev and not ne:
return dummy
if not prev:
head.next = ne
return dummy
else:
t2 = prev.next
prev.next = dummy
t2.next = ne
return head
while L:
if even_turn:
evenitr.next = L
evenitr = evenitr.next
else:
odditr.next = L
odditr = odditr.next
# Alternate betweent True and False
even_turn ^= True
L = L.next
odditr.next = None
evenitr.next = oddhead.next
return evenhead.next
if __name__ == '__main__':
L = ListNode(0)
L.next = ListNode(1)
L.next.next = ListNode(2)
L.next.next.next = ListNode(3)
L.next.next.next.next = ListNode(4)
L.next.next.next.next.next = ListNode(5)
newlist = merge(L)
while newlist:
print(newlist.data)
newlist = newlist.next
# Print the contents of a linked list using recursion.
from listnode import ListNode
# O(n)
def printList(head):
if head is not None:
printList(head.next)
print(head.data)
a = ListNode(1)
b = ListNode(2)
c = ListNode(3)
a.next = b
b.next = c
printList(a)
class Solution:
def swapPairs(self, head: ListNode) -> ListNode:
dummy = ListNode(0)
dummy.next = head
curr = head
if not curr or not curr.next:
return head
follow = curr.next
curr.next = follow.next
follow.next = curr
dummy.next = follow
head = dummy.next
while curr.next and curr.next.next:
dummy = curr
curr = curr.next
follow = curr.next
curr.next = follow.next
follow.next = curr
dummy.next = follow
return head
four = ListNode(4)
three = ListNode(3)
three.next = four
two = ListNode(2)
two.next = three
one = ListNode(1)
one.next = two
Solution().swapPairs(one)
from listnode import ListNode
if __name__ == '__main__':
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
head.next.next.next.next = ListNode(5)
res = ListNode(0)
curr = res
carry = 0
first = True
while l1 is not None or l2 is not None or carry == 1:
a = 0 if l1 is None else l1.val
b = 0 if l2 is None else l2.val
c = (a + b + carry) % 10
if first:
curr.val = c
first = False
else:
curr.next = ListNode(c)
curr = curr.next
carry = 1 if a + b + carry >= 10 else 0
if l1 is not None:
l1 = l1.next
if l2 is not None:
l2 = l2.next
return res
a = ListNode(9)
a.next = ListNode(9)
b = ListNode(1)
c = Solution().addTwoNumbers(a, b)
while c is not None:
print(c.val)
c = c.next
while fast.next and fast.next.next:
slow, fast = slow.next, fast.next.next
# Reverse second half
tail = slow.next
while tail.next:
temp = tail.next
tail.next = temp.next
temp.next = slow.next
slow.next = temp
# Now compare first half to second half
slow = slow.next
while slow:
if slow.data != L.data:
return False
slow, L = slow.next, L.next
return True
if __name__ == '__main__':
L = ListNode('a')
L.next = ListNode('b')
L.next.next = ListNode('b')
L.next.next.next = ListNode('a')
L.next.next.next.next = ListNode('c')
A = ListNode('c', L)
print(isPalindrome(A))
for value in sorted_list:
# Node (value) points to tail, which is None
sorted_linked_list.next = ListNode(value)
sorted_linked_list = sorted_linked_list.next
# return the first node
return head.next
node1 = ListNode(1)
node2 = ListNode(3)
node3 = ListNode(4)
node4 = ListNode(6)
linked_list1 = ListNode(0)
linked_list1.next = node1
node1.next = node2
node2.next = node3
linked_list_2 = ListNode(1)
linked_list_2.next = node2
node2.next = node3
node3.next = node4
linked_list_3 = ListNode(-2)
linked_list_3.next = node3
node2.next = node4
result = merge([linked_list1, linked_list_2, linked_list_3])
print_list(result)
temp = subtail.next
subtail.next = temp.next
temp.next = subhead.next
subhead.next = temp
return dummyhead.next
# Reverse an entire list without allocating any additional nodes
def reverse_sublist2(L):
head = L
while L.next is not None:
temp = L.next
L.next = temp.next
temp.next = head
head = temp
return head
if __name__ == "__main__":
L = ListNode(1)
L.next = ListNode(2)
L.next.next = ListNode(3)
L.next.next.next = ListNode(4)
newlist = reverse_sublist2(L)
while newlist:
print(newlist.data)
newlist = newlist.next
def push(self, data):
node = ListNode(data)
node.next = self.top
self.top = node
if L1 is None or L2 is None:
return None
count1, count2 = length(L1), length(L2)
diff = abs(count1 - count2)
if count1 > count2:
for _ in range(diff):
L1 = L1.next
elif count2 > count1:
for _ in range(diff):
L2 = L2.next
while L1 is not None or L2 is not None:
if L1 is L2:
break
L1, L2 = L1.next, L2.next
return L1
if __name__ == '__main__':
head1 = ListNode(1)
head1.next = ListNode(2)
head1.next.next = ListNode(3)
head2 = ListNode(-1)
head2.next = ListNode(0)
head2.next.next = head1.next
print(listIntersection(head1, head2).data)