七、链表问题（下）

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