题目描述
给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。k 是一个正整数,它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。
示例:输入:head = [1,2,3,4,5], k = 2. 输出:[2,1,4,3,5]
输入:head = [1,2,3,4,5], k = 3 输出:[3,2,1,4,5]
提示:
- 链表中节点的数量在范围 sz 内,1 <= sz <= 5000
- 0 <= Node.val <= 1000
- 1 <= k <= sz
解题思路
K 个一组翻转链表问题可以使用递归或迭代的方法来实现。其中,迭代方法比递归方法更优,因为递归方法在处理大规模数据时容易出现栈溢出的问题。
迭代方法的基本思路是,每 k 个节点为一组进行翻转,如果剩余节点不足 k 个,则保持原有顺序不变。具体实现时,需要使用 3 个指针:pre、end 和 next,其中 pre 表示待翻转区域的前驱节点,end 表示待翻转区域的后继节点,next 则是遍历链表的指针。
具体步骤如下:
- 初始化指针 pre 为 null,指针 end 和指针 next 均指向头节点 head。
- 对于每个 k 个节点为一组的区间,执行以下操作:
- 从当前位置开始,将指针 next 向后移动 k 个节点,如果剩余节点不足 k 个,则不进行翻转。
- 使用 end 指针记录当前待翻转区域的后继节点。
- 使用 next 指针记录当前待翻转区域的下一个节点。
- 将当前待翻转区域翻转,并返回翻转后的头节点。具体操作可参考翻转链表。
- 如果 pre 为 null,说明当前翻转区域为链表的第一组,需要更新链表头节点为翻转后的头节点,否则将翻转后的头节点接到 pre 的后面。
- 将 pre 更新为当前翻转区域的尾节点,即指针 end。
- 将指针 end 更新为 next,继续处理下一组待翻转区域。
- 返回翻转后的链表头节点。
时间复杂度为 O(n),其中 n 为链表的长度,空间复杂度为 O(1)。
具体代码展示
package org.zyf.javabasic.letcode.list.application;
import org.zyf.javabasic.letcode.list.base.ListNode;
/**
* @author yanfengzhang
* @description 给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。
* k 是一个正整数,它的值小于或等于链表的长度。
* 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。
* 示例:输入:head = [1,2,3,4,5], k = 2. 输出:[2,1,4,3,5]
* 输入:head = [1,2,3,4,5], k = 3 输出:[3,2,1,4,5]
* <p>
* 提示:
* 链表中节点的数量在范围 sz 内,1 <= sz <= 5000
* 0 <= Node.val <= 1000
* 1 <= k <= sz
* @date 2023/4/5 23:32
*/
public class ReverseKGroup {
/*解法:
* 使用迭代法实现链表翻转,每 k 个节点为一组,处理完后将前后两组连接起来。
* 具体实现时,使用 pre 指向待翻转链表的前一个节点,end 指向待翻转链表的尾部节点,
* 然后遍历链表,处理 k 个节点为一组的子链表,将其翻转,并将翻转后的头节点与前面的子链表连接,
* 并将 pre 指向下一组子链表的头节点的前一个节点,end 指向下一组子链表的尾部节点,
* 直到链表遍历完成。
*
* 时间复杂度:O(n),其中 n 是链表的长度。head 节点会在 O(n/k) 段中被翻转,每次翻转的时间复杂度是 O(k)。
* 空间复杂度:O(1)。*/
public ListNode reverseKGroup(ListNode head, int k) {
/*如果链表为空、链表只有一个元素或k=1,则直接返回原链表*/
if (head == null || head.next == null || k == 1) {
return head;
}
/*dummy节点可以避免很多判断和特殊处理,所以一般在链表题目中都会用到*/
ListNode dummy = new ListNode(0);
dummy.next = head;
/*每一段翻转前的前一个节点*/
ListNode pre = dummy;
/*每一段翻转后的尾节点*/
ListNode end = dummy;
while (end.next != null) {
for (int i = 0; i < k && end != null; i++) {
/*将end指针移动到需要翻转的段的最后一个节点*/
end = end.next;
}
if (end == null) {
break;
}
/*每一段翻转前的第一个节点*/
ListNode start = pre.next;
/*记录下一段翻转前的第一个节点*/
ListNode next = end.next;
/*切断当前段和下一段的连接,便于翻转当前段*/
end.next = null;
/*翻转当前段*/
pre.next = reverse(start);
/*连接上一段和当前段,连接当前段和下一段*/
start.next = next;
/*将pre、end移动到下一段翻转前的位置*/
pre = start;
end = start;
}
return dummy.next;
}
/**
* 翻转链表
*/
private ListNode reverse(ListNode head) {
ListNode prev = null;
ListNode cur = head;
while (cur != null) {
ListNode next = cur.next;
cur.next = prev;
prev = cur;
cur = next;
}
return prev;
}
public static void main(String[] args) {
ListNode head = new ListNode(1);
head.next = new ListNode(2);
head.next.next = new ListNode(3);
head.next.next.next = new ListNode(4);
head.next.next.next.next = new ListNode(5);
int k = 2;
System.out.println("Original List: " + printLinkedList(head));
head = new ReverseKGroup().reverseKGroup(head, k);
System.out.println("Reversed List: " + printLinkedList(head));
}
private static String printLinkedList(ListNode head) {
StringBuilder res = new StringBuilder();
while (head != null) {
res.append(head.val).append(" -> ");
head = head.next;
}
res.append("null");
return res.toString();
}
}