Day5 反转链表

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

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

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

python

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        pre = None
        cur = head
        while cur:
            nxt = cur.next
            cur.next = pre
            pre = cur
            cur = nxt
        return pre

c++

class Solution {
public:
    ListNode *reverseList(ListNode *head) {
        ListNode *pre = nullptr, *cur = head;
        while (cur) {
            ListNode *nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }
};

思路： nxt = cur.next 保存当前节点的下一个节点
            cur.next = pre 将当前节点的指针指向上一个节点
            pre = cur 当前指针修改完毕，把前驱指针修改成现在这个节点
            cur = nxt  把当前处理的节点该成下一个节点

92. 反转链表 II

给你单链表的头指针 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]

思路：反转结束后，从原来的链表看，pre指向反转这一段的末尾 cur只想反转这一段后续的下一个节点

在题目中例子反转后是这样的，单纯像第一题一样进行反转后，2指向为空。4 和5没有指针，这时候我们需要设立一个p0指向left节点的前一个节点，将他指向pre，并且将left指向cur

但是特殊情况是当left=1的时候，理论上不存在p0，所以我们需要设立一个侦察节点，指向头指针

有几个节点要反转，循环就执行几次 所以是right-left+1 次

代码部分

dummy指针就是侦察指针，p0就是left的前一个指针

class Solution:
    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        #设置侦察节点
        dummy=ListNode(next=head)
        p0=dummy
        for _ in range(left-1):
            p0=p0.next
        pre=None
        cur=p0.next
        for _ in range(right-left+1):
            nxt=cur.next
            cur.next=pre
            pre=cur
            cur=nxt
        p0.next.next=cur
        p0.next=pre
        return dummy.next

升级版25. K 个一组翻转链表

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

思路

p0指向的是下一个即将反转的链表的前一个节点，如图在1 2 刚完成反转，p0的next还没有变成pre时，它指向的1刚好就是3 前面的节点，也就是即将反转的链表的前一个节点,所以我们只需要提前保留这个值，将他赋给p0的next就可以继续反转下一个组合了

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next


class Solution:
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
       #求链表长度
        n=0
        cur=head
        while cur:
            n+=1
            cur=cur.next

#设置侦察节点，这里不需要向题目二一样求p0，因为题目的意思就是从第一个节点开始反转，p0就等于dummy
        dummy=ListNode(next=head)
        p0=dummy
        while n>=k:
            n=n-k
            pre=None
            cur=p0.next
            for _ in range(k):
                nxt=cur.next
                cur.next=pre
                pre=cur
                cur=nxt
            nxt=p0.next
            p0.next.next=cur
            p0.next=pre
            p0=nxt
               
        return dummy.next