def reverseBetween(self, head, m, n):
"""
:type head: ListNode
:type m: int
:type n: int
:rtype: ListNode
"""
if head is None or head.next is None or m == n:
return head
headnode = ListNode(-1)
headnode.next = head
anchor = headnode
for _ in range(m - 1):
anchor = anchor.next
a = anchor.next
b = a.next
c = b.next
k = n - m
for _ in range(k):
b.next = a
if c:
a, b, c = b, c, c.next
else:
a, b = b, c
anchor.next.next = b
anchor.next = a
return headnode.next
def addTwoNumbers(self, l1, l2):
headnode = ListNode(0)
p = headnode
p1, p2 = l1, l2
carry = 0
# 处理等长部分
while p1 and p2:
val = p2.val + p1.val + carry
p.next = ListNode(val % 10)
carry = val // 10
p, p1, p2 = p.next, p1.next, p2.next
# 处理不等长的部分
while p1:
val = p1.val + carry
p.next = ListNode(val % 10)
carry = val // 10
p, p1 = p.next, p1.next
while p2:
val = p2.val + carry
p.next = ListNode(val % 10)
carry = val // 10
p, p2 = p.next, p2.next
if carry > 0:
p.next = ListNode(carry)
return headnode.next
def addAtHead(self, val):
"""
Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
:type val: int
:rtype: void
"""
newnode = ListNode(val)
newnode.next, self.headnode.next = self.headnode.next, newnode
if self.length == 0:
self.tail = newnode
self.length += 1
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
bonus = 0
c = l1
len1 = 0
while c:
len1 += 1
c = c.next
c = l2
len2 = 0
while c:
len2 += 1
c = c.next
if len1 < len2:
l1, l2 = l2, l1
prettyPrintLinkedList(l1)
prettyPrintLinkedList(l2)
res = l1
while l2:
bonus, l1.val = divmod(l1.val+l2.val+bonus, 10)
last = l1
l1 = l1.next
l2 = l2.next
while bonus and l1:
bonus, l1.val = divmod(l1.val+bonus, 10)
last = l1
l1 = l1.next
if bonus:
last.next = ListNode(1)
return res
def insertionSortList(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if head is None or head.next is None:
return head
sorted = head
unsorted = head.next
inf = ListNode(float("inf"))
sorted.next = inf
# sorted.next.next = sorted
while unsorted:
c = sorted
while c.val < unsorted.val:
c = c.next
temp = unsorted
unsorted = unsorted.next
temp.next = c.next
c.next = temp
c.val, temp.val = temp.val, c.val
while True:
if c.next.val == float("inf"):
break
c = c.next
c.next = None
return sorted
def __init__(self):
"""
Initialize your data structure here.
"""
self.headnode = ListNode(None)
self.length = 0
self.tail = None
def addAtTail(self, val):
"""
Append a node of value val to the last element of the linked list.
:type val: int
:rtype: void
"""
newnode = ListNode(val)
if self.tail:
self.tail.next = newnode
else: # the first node
self.headnode.next = newnode
self.tail = newnode
self.length += 1
def _get(self, index):
"""
Get the value of the index-th node in the linked list. If the index is invalid, return -1.
:type index: int
:rtype: int
"""
if index >= self.length:
return ListNode(-1)
else:
c = self.headnode.next
for _ in range(index):
c = c.next
return c
def deleteDuplicates(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
headnode = ListNode(None)
headnode.next = head
delete = False
p = headnode # prev
c = head # current
while c:
while c.next and c.val == c.next.val:
c.next = c.next.next
if not delete:
delete = True
if delete:
c = c.next
p.next = c
delete = False
else:
c = c.next
p = p.next
return headnode.next
def addAtIndex(self, index, val):
"""
Add a node of value val before the index-th node in the linked list.
If index equals to the length of linked list, the node will be appended to the end of linked list.
If index is greater than the length, the node will not be inserted.
:type index: int
:type val: int
:rtype: void
"""
if index < 0 or index > self.length:
return None
if index == 0:
self.addAtHead(val)
elif index == self.length:
self.addAtTail(val)
else:
insert_point = self._get(index)
newnode = ListNode(insert_point.val)
newnode.next = insert_point.next
insert_point.next = newnode
insert_point.val = val
self.length += 1
if insert_point is self.tail:
self.tail = insert_point.next