2、两数相加（中等）
题目描述
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
- 每个链表中的节点数在范围 [1, 100] 内
- 0 <= Node.val <= 9
- 题目数据保证列表表示的数字不含前导零
题目思路
对于这道题，要求我们将两个用链表形式保存的数据进行加和计算，思路类似于通过按位计算的方法获得大数结果。
链表从开头到结尾，分别从低位到高位，因此在相加上要注意几个点：
- 两数的位数可能是不同的，反应到链表就是长度不同；
- 加和是存在进位的，这点在每一位的计算中都要考虑；
- 每一位展现的值，为
(val1 + val2 + carry) % 10；
算法代码
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode() # 创建一个虚拟头节点作为结果链表的起始位置
curr = dummy # 使用一个指针指向结果链表的当前位置
carry = 0 # 初始化进位为0
# 遍历两个输入链表，直到两个链表都到达末尾
while l1 or l2:
# 获取当前节点的值，并将指针指向下一个节点
val1 = l1.val if l1 else 0
val2 = l2.val if l2 else 0
total = val1 + val2 + carry
# 计算进位和当前节点的值
carry = total // 10
digit = total % 10
# 创建新节点，并将指针移动到新节点
curr.next = ListNode(digit)
curr = curr.next
# 移动输入链表的指针
if l1:
l1 = l1.next
if l2:
l2 = l2.next
# 处理最后的进位
if carry:
curr.next = ListNode(carry)
return dummy.next # 返回结果链表的头部
19、删除链表的倒数第N个节点（中等）
题目描述
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
提示：
- 链表中结点的数目为 sz
- 1 <= sz <= 30
- 0 <= Node.val <= 100
- 1 <= n <= sz
进阶： 你能尝试使用一趟扫描实现吗？
题目思路
对于这道题，要求我们找到倒数第n个链表节点，并且删除该节点。
本质上来说，可以拆分为两部分：
- 找到倒数第n个节点的位置（前一个位置）；
- 删除倒数第n个节点；
对于第一部分问题，当然可以先去做一次遍历、找到链表长度，然后再根据n计算位置。
这样使用了两趟扫描。
如果我们希望只遍历一趟、找到倒数第n个节点，实际上可以使用快慢指针的方法：
- 定义快慢指针，让快指针先走n步，然后快慢指针一起走；
- 当快指针走到链表尾节点时，慢指针与快指针的节点差为n，此时正好满足慢指针的下一个节点就是倒数第n个节点；
对于第二部分问题，链表所谓的删除节点n，就是要找到节点n的前一个节点，而后执行next = next.next的操作即可。
算法代码
class Solution:
def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
# 双指针法
dummy = ListNode(-1)
dummy.next = head
fast, slow = dummy, dummy
while n > 0:
fast = fast.next
n -= 1
while fast.next:
slow = slow.next
fast = fast.next
slow.next = slow.next.next
return dummy.next
24、两两交换链表中的节点（中等）
题目描述
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
提示：
- 链表中节点的数目在范围 [0, 100] 内
- 0 <= Node.val <= 100
题目思路
对于这道题，要求我们对链表中的两两元素分别交换位置。
这里，我们有迭代和递归两种方法。
1、迭代
对于迭代法，由于在交换两个节点的过程中需要更改二者的next关系，因此我们需要记录三个节点：
- 待交换的两个节点
node1、node2； - 前置节点
temp；
具体而言，交换之前的节点关系是 temp -> node1 -> node2，交换之后的节点关系要变成 temp -> node2 -> node1，因此需要进行如下操作。
temp.next = node2
node1.next = node2.next
node2.next = node1
完成上述操作之后，节点关系即变成 temp -> node2 -> node1。再令 temp = node1，对链表中的其余节点进行两两交换，直到全部节点都被两两交换。
2、递归
递归的终止条件是：
- 链表中没有节点，或者链表中只有一个节点，此时无法进行交换。
而节点交换的本质就是第二个节点指向第一个节点、第一个节点指向第三个节点，而第三个节点递归进行交换动作。
算法代码
1、迭代
class Solution:
def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode(-1)
dummy.next = head
temp = dummy
while temp.next and temp.next.next:
node_1 = temp.next
node_2 = temp.next.next
temp.next = node_2
node_1.next = node_2.next
node_2.next = node_1
temp = node_1
return dummy.next
2、递归
class Solution:
def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
if head is None or head.next is None:
return head
first = head
second = head.next
third = head.next.next
second.next = first
first.next = self.swapPairs(third)
return second
25、K个一组翻转链表（困难）
题目描述
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
示例1：
输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例2：
输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
提示：
- 链表中的节点数目为 n
- 1 <= k <= n <= 5000
- 0 <= Node.val <= 1000
进阶：
你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？
题目思路
对于这道题，要求我们对一个链表进行每k个节点一组、进行分组翻转。
如果节点个数不够k个，则不进行翻转。
步骤拆解：
- 链表分区为已翻转部分+待翻转部分+未翻转部分；
- 每次翻转前，要确定翻转链表的范围，这个必须通过
k此循环来确定； - 需记录翻转链表前驱和后继，方便翻转完成后把已翻转部分和未翻转部分连接起来；
- 初始需要两个变量
pre和end，pre代表待翻转链表的前驱，end代表待翻转链表的末尾； - 经过
k此循环，end到达末尾，记录待翻转链表的后继new_start = end.next； - 翻转链表，然后将三部分链表连接起来，然后重置
pre和end指针，然后进入下一次循环； - 特殊情况，当翻转部分长度不足
k时，在定位end完成后，end==null，已经到达末尾，说明题目已完成，直接返回即可；
算法代码
class Solution:
def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
if head is None or head.next is None:
return head
dummy = ListNode(-1)
dummy.next = head
# 初始化pre和end都指向dummy
# pre指每次要翻转的链表的头结点的上一个节点
# end指每次要翻转的链表的尾节点
pre = dummy
end = dummy
while end.next:
# 循环k次，找到需要翻转的链表的结尾
# dummy->1->2->3->4->5
# 若k为2，循环2次，end指向2
for i in range(k):
if end is None:
break
end = end.next
# 如果此时end为None，说明当前待翻转链表节点数小于k，不执行翻转动作
if end is None:
break
# 定义new_start，记录下一部分的开始位置，方便前面翻转后连接
new_start = end.next
# 断开前后链表
end.next = None
# 记录需要翻转链表的头结点
curr_start = pre.next
# 翻转链表，pre.next指向翻转后的链表。1->2 变成2->1，即dummy->2->1
pre.next = self._reverse_list(curr_start)
# 翻转后头节点变到最后，通过node.next把断开的链表重新链接
curr_start.next = new_start
# 将pre换成下次要翻转的链表的头结点的上一个节点。即curr_start
pre = curr_start
# 翻转结束，将end置为下次要翻转的链表的头结点的上一个节点。即curr_start
end = curr_start
return dummy.next
def _reverse_list(self, head: Optional[ListNode]) -> Optional[ListNode]:
prev_node = None
while head:
next_node = head.next
head.next = prev_node
prev_node = head
head = next_node
return prev_node
