力扣24.两两交换链表中的节点、25.K个一组反转链表

24.两两交换链表中的节点

一、迭代

思路：

与之前的类似，创建一个虚拟节点，来统一处理方式，然后就是按照一般的链表思路进行操作，重要的是自己在草稿本上画好图，分清楚什么时候两个节点之间的连接断了，先变动什么节点后变动什么节点。

代码：

python 复制代码

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head:
            return head
        if not head.next:
            return head
        
        dum = ListNode(next=head)
        pre = dum
        cur = dum.next

        while pre and cur and pre.next and cur.next:
            pre.next = cur.next
            cur.next = pre.next.next
            pre.next.next = cur
            pre = cur
            if cur:
                cur = cur.next

        return dum.next

复杂度分析：

时间复杂度：O(n)，其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。
空间复杂度：O(1)。

二、递归

递归三部曲：

1、参数及返回值：参数已确定，返回值为交换后的链表头节点（即节点2）

2、递归终止条件：链表中没有节点，或者链表中只有一个节点，此时无法进行交换。

3、递归内操作：确定三个节点后，节点1指向由节点3返回的交换后的节点，节点2指向节点1

代码：

python 复制代码

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
            return head
        
        node1 = head
        node2 = head.next
        node3 = node2.next

        node1.next = self.swapPairs(node3)
        node2.next = node1

        return node2

25.K个一组反转链表

思路：

我自己没写出来，大概知道是用反转列表来操作但死脑不想再动了...不太好解释，建议看了代码自行进行一个循环的模拟就能够理解链表指向是如何修改的了

参考：

https://leetcode.cn/problems/reverse-nodes-in-k-group/solutions/1992228/you-xie-cuo-liao-yi-ge-shi-pin-jiang-tou-plfs

代码：

python 复制代码

class Solution:
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        # 统计节点个数
        n = 0
        cur = head
        while cur:
            n += 1
            cur = cur.next

        p0 = dum = ListNode(next=head)
        pre = None
        cur = head

        # 每 k 个一组处理
        while n >= k:
            n -= k
            for _ in range(k):
                temp = cur.next
                cur.next = pre
                pre = cur
                cur = temp

            # 只能说自行模拟一下，以[1, 2, 3, 4], k=2为例在纸上画一下，就知道是如何修改链表的指向的了
            temp = p0.next
            temp.next = cur
            p0.next = pre
            p0 = temp

        return dum.next