Python：在指定区间反转链表 【算法村E2链表反转笔记（白银）】

前言

距离上一次动笔已经有四五天，实感时间荒废之恨。

话不多说，来看解法。本文提供三种解法：递归法，与两种不同的迭代法。

题目：

---

目录

方法一：递归

方法二：“头插法”

方法三：“穿针引线法”

---

方法一：递归

首先看代码：

class Solution:
    # 方法一：递归
    successor = None # 后继节点
    def reverseN(self,head,n): # 反转前n个节点
        global successor
        if n == 1: 
            # base case
            # 记录第n+1个节点
            successor =  head.next
            return head
        # 以head.next为起点，反转前n-1个节点
        last = self.reverseN(head.next, n-1)

        head.next.next = head
        # 让反转之后的 head 节点和后面的节点连起来
        head.next = successor
        return last
    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        if left == 1:
            return self.reverseN(head, right)
        # 前进到反转的起点触发base case
        # 左值为什么是head.next：相当于取当前完整链表的子链表，这个子链表就是去掉当前链表的头，也即链表一直去头，直到那个头就是起始的反转节点为止
        # head.next 必须接收对 head.next 的递归返回值，否则无法做到修改链表结构的作用
        head.next = self.reverseBetween(head.next, left-1, right-1)
        return head

base case为“n==1的情况”，此时我们设定后继节点为head.next，并且返回head（由于n==1，这里的head其实就是last）。后继节点放在函数外，以免每次递归的时候都被设空导致某些问题的出现。

在if函数之外的部分与前文相同，读者可自行参阅。

看完反转函数，我们来看主函数。

如果left==1，符合我们写的反转函数，则直接返回运行结果即可。

否则，不断向前试探，直到符合上述情况。

运行结果：

---

方法二：“头插法”

首先看代码：

    # 方法二：头插法(只遍历一遍)
    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        dummy = ListNode(-1)
        dummy.next = head
        pre = dummy
        for i in range(left-1):
            pre = pre.next
            
        cur = pre.next # 反转的起点
        for i in range(right-left):
            tmp = cur.next
            cur.next = tmp.next
            tmp.next = pre.next
            pre.next = tmp
        return dummy.next

尽管代码十分简洁，理解有些压力。

首先我们设虚拟头节点以防止头节点为的空特殊情况。

将pre移动到标定为left的左侧一个节点。（如：left=3，第三个节点，我们将pre移动到链表第二个节点）

随后让cur表示反转的起点（即标定left的节点）。

下一个for函数中，我们进行反转操作。与普通的反转链表不同之处在于，这里的tmp并不是简单的中间变量，而也要参与到翻转过程。

例如现在反转（1 -> ）2 -> 3 -> 5 -> 7：

首先，（pre=1），cur=2，tmp=3；

随后，2指向5,3指向2，即：（1 -> ）2，3 -> 2 -> 5 -> 7；

最后，让pre指向3，即：（1 -> ）3 -> 2 -> 5 -> 7；

可见，我们只需要一共操作right-left=3次，就可以将这一段链表全部反转。

当全部执行完，返回虚拟头节点的next即可。

运行结果：

---

方法三：“穿针引线法”

首先看代码：

    # 方法三：穿针引线法（遍历两遍）
    def reverse_linked_list(self,head:ListNode):
        pre = None
        cur = head
        while cur:
            nxt = cur.next
            cur.next = pre
            pre = cur
            cur = nxt

    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        dummy = ListNode(-1)
        dummy.next = head
        pre = dummy

        for _ in range(left - 1):
            pre = pre.next
        
        right_node = pre
        for _ in range(right - left + 1):
            right_node = right_node.next
        
        left_node = pre.next
        succ = right_node.next

        pre.next = None
        right_node.next = None

        self.reverse_linked_list(left_node)

        pre.next = right_node
        left_node.next = succ

        return dummy.next

首先，依然设置虚拟头节点。

以下一共分为5步：

第一步，pre从虚拟头节点走left-1步，走到left前一个节点。

第二步，right_node从现在的pre走right-left+1步，走到right节点。

第三步，切出我们想要的子链表，即从左节点到右节点。同时，要切断主链表与子链表的连接，以便后续反转该子链表。

第四步，我们反转子链表。

第五步，将反转后的子链表接回原来的链表中。

运行结果：