算法学习6—链表 - 反转系列

反转链表【基础算法精讲 06】_哔哩哔哩_bilibili

206. 反转链表 

206. 反转链表

 

示意图

 首先输入是 [1,2,3,4,5] ，从头结点开始反转，初始时，pre指向空，cur是当前节点，nxt是写一个待反转的节点，首先给出下一个待反转的节点，然后让当前节点指向pre，然后pre向后移一个，cur也是向后移一个，依次循环即可。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
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

92. 反转链表 II

92. 反转链表 II

 

 示例图

# 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]:
        p0 = dummy = ListNode(next=head) # 添加哨兵
        # 移动到反转区间前一个位置
        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  # 每次循环只修改一个 next，方便大家理解
            pre = cur
            cur = nxt

        p0.next.next = cur #当前p0.next是2，再.next则是代表的是把尾巴续上
        p0.next = pre
        return dummy.next

25. K 个一组翻转链表

25. K 个一组翻转链表

 

# 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 = dummy = ListNode(next=head)
        
        pre = None
        cur = head
        while n >= k:
            n -= k
            for _ in range(k):  # 同 92 题
                nxt = cur.next
                cur.next = pre  # 每次循环只修改一个 next，方便大家理解
                pre = cur
                cur = nxt

            nxt = p0.next
            nxt.next = cur
            p0.next = pre
            p0 = nxt
        return dummy.next

首先计算链表长度，然后初始化一个哨兵，进入循环后，每次反转k个节点，在每次反转完成后，先保存新的哨兵节点到nxt，然后进行链表续接，然后把nxt作为新的p0，继续反转。