力扣25(java&python)-K 个一组翻转链表（困难）

题目：

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

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

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

示例1：

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

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

示例2：

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

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

提示：

• 链表中的节点数目为 n
• 1 <= k <= n <= 5000
• 0 <= Node.val <= 1000

进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

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

解题思路：

一、模拟

参考 @康建斌学算法 大佬的解题思路，同时感谢评论区的各位提的疑问以及注解~

1.设置虚拟头结点，指向原始头结点将头结点当做普通结点来对待，减少特殊判断，将链表分区为已翻转部分+待翻转部分+未翻转部分；

2.定义两个指针，pre：每次要翻转链表头结点的前一个结点，end:待翻转链表的尾结点，让其初始都指向虚拟结点；

3.对链表进行遍历，首先通过给定的k来循环，找到第一次需要翻转的链表的范围；

 4.经过k次循环后，end到达本次待翻转链表的尾结点，需要保存尾结点的下一个结点：ListNode next = end.next，找到待翻转链表的开始结点: ListNode start = pre.next，并断开end与next的连接：end.next = null;

 5.对[start,end]区间的结点进行翻转，将这个待翻转的子链表进行操作：

•  定义三个指针，preNode：前一个结点指针，currNode：当前结点指针，nextNode：下一个结点指针；

• 然后对待翻转的结点进行循环，循环结束的条件是：当 当前结点为空：
  • 先保存当前结点后面链表： nextNode = currNode.next;

• • 将当前结点指向preNode： currNode.next = preNode;

 

 

• •  更新preNoded位置，preNode向后移动指向当前结点：preNode = currNode；更新curNode位置，curNode向后移动，下一个结点变成当前结点：currNode = nextNode;

• • 最后实现全部翻转，currNode为空，返回这时的preNode

5.将pre.next指向翻转后的链表：pre.next = reverse(start);并将已翻转的部分和待翻转的部分连接，尾结点指向它的下一个结点：

  start.next = next;并且将pre和end重置为下一次翻转链表头结点的前一个结点；

 6.一直重复上述步骤，直到end为null时，结束遍历，最终返回 dummyHead.next。

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 reverseKGroup(ListNode head, int k) {
        //定义一个虚拟结点并指向头结点
        ListNode dummyHead = new ListNode(0,head);
        //定义两个指针初始都指向虚拟结点
        //pre:每次要翻转链表头结点的前一个结点
        //end:要翻转链表的尾结点
        ListNode pre = dummyHead;
        ListNode end = dummyHead;
        //当到达尾结点的时候退出while循环
        //找到end的位置
        while(end.next != null){
            //end != null:防止end.next为空报错
            for(int i = 0; i < k && end != null; i++){
                end = end.next;
            }
            //当不足k倍时，直接退出不进行翻转
            if(end == null) break;

            //翻转的开始结点
            ListNode start = pre.next;
            //保存end的下一个结点
            ListNode next = end.next;
            //断开end和下一个结点的连接
            end.next = null;
            //将pre.next指向翻转后的链表
            pre.next = reverse(start);
            //将尾结点指向end的下一个结点
            start.next = next;
            //将pre换成下一次翻转链表头结点的前一个结点
            pre = start;
            //将end也要换成下一次翻转链表头结点的前一个结点
            end = start;
        }
        //最后返回虚拟头结点的下一个结点=真正的头结点
        return dummyHead.next;
    }
    public ListNode reverse(ListNode head){
        //当子链表为空或者只有单结点时，直接返回原表
        if(head == null || head.next == null) return head;
        //定义三个指针
        //preNode前一个结点指针
        //currNode当前结点指针
        //nextNode下一个结点指针
        ListNode preNode = null;
        ListNode currNode = head;
        ListNode nextNode = null;
        //循环结束条件是当当前结点为空
        while(currNode != null){
            //先保存下一个结点
            nextNode = currNode.next;
            //当前结点指向preNode
            currNode.next = preNode;
            //更新preNoded位置
            preNode = currNode;
            //更新curNode位置
            currNode = nextNode;
        }
        return preNode;
    }
}

 python3代码：

# 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]:
        dummyHead = ListNode(0,head)
        pre, end = dummyHead, dummyHead
        while end.next:
            # 确定end的位置
            i = 0
            while i < k and end:
                end = end.next
                i += 1
            # end为空
            if not end:
                break
            # start的位置
            start = pre.next
            # 保存end的下一个结点并断开连接
            next = end.next
            end.next = None

            # 将pre连接已翻转的链表
            pre.next = self.reverse(start)

            # 将start连接下一个待翻转的链表
            start.next = next
            # 更新pre和end的位置,在下一个翻转链表头结点的前一个结点
            pre = start
            end = start
        return dummyHead.next

    def reverse(self, head):
        # 特殊判断
        if not head or not head.next:
            return head
        cur = head
        pre = None
        next = None
        while cur:
            # 保存cur下一个结点
            next = cur.next
            # 将cur指向pre
            cur.next = pre
            # 将pre移动到cur,将cur移动到next
            pre = cur
            cur = next
        return pre

 二、递归

1.设定一个end指针，初始指向head处

 2.找到待翻转的k个结点，如果剩余结点的数量小于k，则不需要翻转，直接返回剩下部分的头结点就行；

 3.对[head,end）区间的结点进行翻转（翻转的结点不包括end），并返回翻转后的头结点newHead；

 4.再以同样的方式，对剩下的结点进行翻转：head.next = reverseKGroup(end, k);

 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 reverseKGroup(ListNode head, int k) {
        //特殊判断
        if(head == null || head.next == null) return head;
        //设定一个end指针
        ListNode end = head;
        for(int i = 0; i < k; i++){
            //如果剩下的结点不足k个
            if(end == null) return head;
            end = end.next;
        }
        //翻转前k个元素
        ListNode newHead = reverse(head, end);
        //下一轮翻转从end开始
        head.next = reverseKGroup(end, k);

        return newHead;
    }
    public ListNode reverse(ListNode head, ListNode end){
        //定义两个指针
        //preNode前一个结点指针
        //nextNode下一个结点指针
        ListNode preNode = null;
        ListNode nextNode = null;
        //循环结束条件是当head没有到尾结点时
        while(head != end){
            //先保存下一个结点
            nextNode = head.next;
            //当前结点指向preNode
            head.next = preNode;
            //更新preNoded位置
            preNode = head;
            //更新head位置
            head = nextNode;
        }
        return preNode;
    }
}

 python3代码：

# 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]:
        # 特殊判断
        if not head or not head.next:
            return head
        end = head

        for i in range(k):
            # not end:end为空，不足k个
            if not end:
                return head
            end = end.next

        # 翻转链表
        newHead = self.reverse(head, end)
        # 递归翻转剩下的
        head.next = self.reverseKGroup(end, k)

        return newHead

    def reverse(self, head, end):
        pre = None
        next = None
        while head != end:
            # 保存head下一个结点
            next = head.next
            # 将head指向pre
            head.next = pre
            # 将pre移动到head,将head移动到next
            pre = head
            head = next
        return pre