题目
给你一个链表,每 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]
输入:head = [1,2,3,4,5], k = 1
输出:[1,2,3,4,5]
输入:head = [1], k = 1
输出:[1]
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/reverse-nodes-in-k-group
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
方法1:线性表
和143用的方法一样
Java实现
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
List<ListNode> list = new ArrayList<>();
ListNode tmp = head;
int sum = 0;
while (tmp != null){
list.add(tmp);
tmp = tmp.next;
sum++;
}
int l = 0, r = l + k - 1;
int n = list.size();
ListNode dummy = new ListNode();
ListNode pre = dummy;
while (l < n && r < n){
int i = l, j = r;
while (j >= i){
pre.next = list.get(j);
list.get(j).next = null;
pre = pre.next;
j--;
}
l = r + 1;
r = l + k - 1;
}
if (sum % k == 0) return dummy.next;
else {
int j = list.size() - sum % k;
while (j < n){
pre.next = list.get(j);
pre = pre.next;
j++;
}
return dummy.next;
}
}
}
方法2:递归
太巧妙了
Java实现
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
if (head == null) return null;
ListNode a, b;
a = b = head;
for (int i = 0; i < k; i++){
//不足k个不反转
if (b == null) return head;
b = b.next;
}
//反转前k个元素
ListNode newHead = reverse(a, b);
// 递归反转后续链表并连接起来
a.next = reverseKGroup(b, k);
return newHead;
}
//翻转从结点a到结点b的链表,并返回头结点。
public ListNode reverse(ListNode a, ListNode b){
ListNode pre = null, cur = a, nxt = a;
while (cur != b){
nxt = cur.next;
cur.next = pre;
pre = cur;
cur = nxt;
}
return pre;
}
}