力扣92(java&python)-反转链表Ⅱ（中等）

题目：

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

示例1：

输入：head = [1,2,3,4,5], left = 2, right = 4

输出：[1,4,3,2,5]

示例2：

输入：head = [5], left = 1, right = 1

输出：[5]

提示：

链表中节点数目为 n
1 <= n <= 500
-500 <= Node.val <= 500
1 <= left <= right <= n
 

进阶： 你可以使用一趟扫描完成反转吗？

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/reverse-linked-list-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路：

一、头插法

1.首先定义一个虚拟头结点指向原始头结点，可以减少对头结点的特殊处理，将头结点当做普通结点处理；

2.定义两个指针一个为pre，一个为cur；

3.确定pre和cur指针的位置，需要根据题中给定的left值进行确定，将pre移动到第一个需要反转的结点的前面，将cur移动到需要反转的第一个结点上；

4.将cur后面一个结点temp保存，将当前cur指向cur的下下个结点，即cur.next=cur.next.next , 然后将保存的结点插入到pre后面；

5.重复步骤4;

6.最后返回dummyHead.next。

解释：

temp.next = pre.next这里为什么不能写成temp.next = cur？

看上面的图解就可以看出，cur所指向的结点没有变过，但是所在的位置是一直在变化的，pre和cur中间会一直插入结点，而每次插入都是在pre的后面。如果写成temp.next = cur就会删除上面已经反转的结点，比如4和3。

java代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        ListNode dummyHead = new ListNode(0,head);
        //定义两个指针pre和cur
        ListNode pre = dummyHead;
        ListNode cur = dummyHead.next;

        //先确定两个指针的初始位置，pre应该在left-1,cur=left
        for(int i = 1; i < left; i++){
            pre = pre.next;
            cur = cur.next;
        }
        //插入
        for(int j = 1; j < right - left + 1; j++){
            //保存cur的下一个结点
            ListNode temp = cur.next;
            //使cur指向它的下下个结点
            cur.next = cur.next.next;
            //将保存的结点插入
            temp.next = pre.next;
            pre.next = temp;
        }
        return dummyHead.next;

    }
}

 python3代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        dummyHead = ListNode(0,head)
        pre,cur = dummyHead,dummyHead.next

        # 确定pre和cur的位置
        for i in range(1,left):
            cur = cur.next
            pre = pre.next
        
        # 插入操作
        for i in range(1,right-left+1):
            temp = cur.next
            # 如果temp是尾结点cur.next为none
            cur.next = temp.next if temp else None

            temp.next = pre.next
            pre.next = temp
        
        return dummyHead.next

 二、递归

reverseBetween()：含义就是将拿到的链表进行反转，然后返回反转后的链表的头结点（递归的过程想的太仔细，很容易绕进去，其实清楚最后返回的头结点的是谁最重要）

详解参考@编程狂想曲

java代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        if (left == 1){
            return reversTopN(head, right);
        }
       //翻转
       ListNode between = reverseBetween(head.next, left-1, right-1);
       //将翻转后的新头结点挂在原来的head之后
       head.next = between;
       //返回链表
       return head;
    }
    //nextnode第n个结点之后的结点
    ListNode nextnode = null;
    private ListNode reversTopN(ListNode head, int n){
        //如果只翻转一个，把下一个结点直接放在头结点后
        if(n == 1){
            nextnode = head.next;
            return head;
        }
        ListNode newHead = reversTopN(head.next, n-1);
        //头结点的下一个结点指向头结点
        head.next.next = head;
        head.next = nextnode;
        return newHead;
    }
}