def reverseList(self, head: ListNode) -> ListNode:
if not head or not head.next:
return head
node = self.reverseList(head.next)
head.next.next = head
head.next = None
return node
def getLinkLength(node: ListNode) -> int:
head = ListNode(-1, node)
count = 0
while head.next:
count += 1
head = head.next
return count
def isPalindrome(self, head: ListNode) -> bool:
"""
寻找链表的中间节点，在中间节点处将链接分为两半，并将前半段反转
如
[1, 2, 3, 2, 1]
分为
[1, 2, 3]
[5, 4]
"""
dummy = ListNode(-1, head)
slow = dummy
fast = slow.next
count = 0
while fast:
count += 1
fast = fast.next
slow = slow.next
if fast:
count += 1
fast = fast.next
second_half = slow.next
if count % 2 == 0:
slow.next = None
return equals(reverseLink(head), second_half)
slow.next = None
return equals(reverseLink(head).next or head, second_half or head)
def reverseLink(head: ListNode) -> ListNode:
if not head or not head.next:
return head
node = reverseLink(head.next)
head.next.next = head
head.next = None
return node
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
dummy = ListNode(-1, head)
front, back = head, dummy
for i in range(n):
front = front.next
# if front is None:
# return dummy.next
while front is not None:
front = front.next
back = back.next
back.next = back.next.next
return dummy.next
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
"""
反转两个链表
从最低位开始相加
"""
l1 = reverseLink(l1)
l2 = reverseLink(l2)
dummy = ListNode(-1)
node = dummy
carry = 0
while l1 or l2:
cnt = (l1 and l1.val or 0) + (l2 and l2.val or 0) + carry
node.next = ListNode(cnt % 10)
node = node.next
carry = int(cnt / 10)
if l1:
l1 = l1.next
if l2:
l2 = l2.next
if carry:
node.next = ListNode(carry)
return reverseLink(dummy.next)
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
if not l1 and not l2:
return None
if not l2:
l2 = ListNode(0)
if not l1:
l1 = ListNode(0)
l1.val = l1.val + l2.val
if l1.val > 9:
l1.val = l1.val - 10
if l1.next:
l1.next.val += 1
else:
l1.next = ListNode(1)
l1.next = self.addTwoNumbers(l1.next, l2.next)
return l1
def reorderList(self, head: ListNode) -> None:
"""
寻找链表的中间节点，在中间节点处将链接分为两半, 然后穿插两个链表
如
[1, 2, 3, 4, 5]
分为
[1, 2, 3]
[5, 4]
[1, 2, 3, 4]
分为
[1, 2]
[4, 3]
"""
dummy = ListNode(-1, head)
slow = dummy
fast = dummy.next
while fast:
fast = fast.next
slow = slow.next
if fast:
fast = fast.next
right = slow.next
slow.next = None
left = dummy.next
right = reverseLink(right)
while left:
node = left.next
left.next = right
if right:
node2 = right.next
right.next = node
right = node2
left = node
return None
def call(self, a: List[int], b: List[int]) -> int:
node = self.getIntersectionNode(ListNode.fromList(a),
ListNode.fromList(b))
return node.val
def call(self, l: List[int]) -> List[int]:
node = self.reverseList(ListNode.fromList(l))
return node and node.toList() or []
def call(self, data: List[int], k: int) -> List[int]:
head = self.removeNthFromEnd(ListNode.fromList(data), k)
return head and head.toList() or []
def call(self, data: List[int]) -> bool:
return self.isPalindrome(ListNode.fromList(data))
def call(self, l1: List[int], l2: List[int]) -> List[int]:
node = self.addTwoNumbers(ListNode.fromList(l1), ListNode.fromList(l2))
if not node:
return []
return node.toList()
def call(self, data: List[int]) -> List[int]:
head = ListNode.fromList(data)
self.reorderList(head)
return head.toList()
def call(self,
data: List[int],
val: int,
cycle: int = -1) -> Tuple[int, int]:
node = self.insert(ListNode.fromList(data, cycle), val)
return node.val
def call(self, data: List[int], cycle: int) -> int:
node = self.detectCycle(ListNode.fromList(data, cycle))
if not node:
return -1
return node.val
