给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。
k 是一个正整数,它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。
示例 :
给定这个链表:1->2->3->4->5
当 k = 2 时,应当返回: 2->1->4->3->5
当 k = 3 时,应当返回: 3->2->1->4->5
说明:
你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
方法一:主要想到用栈去接受,退出来正好是倒叙的,这种要求会超出内存限制
你的算法只能使用常数的额外空间 ,时间复杂度O(N),额外空间复杂度O(k)
方法二:在链表里尽量少用其他方法开辟空间,会超限制的,应该通过交换来与92题比较相似
时间复杂度O(N),额外空间复杂度O(1);
*/
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
//时间复杂度O(n),空间复杂度O(k)
// if(k<2) {
// return head;
// }
// //创建个新节点
// ListNode dummay = new ListNode(0);
// //定义个中间变量去接受
// ListNode cur = dummay;
// //cur = head; //添加这一步为啥就导致 return dummay.next;输不出去
// ListNode sumNode = head;
// //创建个栈
// Stack<ListNode> stack = new Stack<>();
// //System.out.println(head.val);
// int s=0;
// //统计有几个值
// while(sumNode != null) {
// sumNode =sumNode.next;
// s++;
// }
// //System.out.println(cur);
// int h= s/k;
// //System.out.println(h);
// //用h去定义要倒叙几次
// for(int i=0;i<h;i++) {
// for(int j=0;j<k;j++) {
// //放进站
// stack.push(head);
// head = head.next;
// }
// //倒出来存cur里
// while(!stack.isEmpty()) {
// cur.next = stack.pop();
// cur = cur.next;
// System.out.print(cur.val);
// }
// }
// //System.out.println(head.val);
// //当节点不是k的整数倍时后面还有节点,继续存进去
// while(head != null) {
// cur.next = head;
// cur= cur.next;
// head = head.next;
// }
// return dummay.next;
ListNode dummy = new ListNode(0), prev = dummy, curr = head, next;
dummy.next = head;
int length = 0;
//统计节点个数
while(head != null) {
length++;
head = head.next;
}
//将头节点在赋给head从头开始
// head = dummy.next;
for(int i = 0; i < length / k; i++) {
for(int j = 0; j < k - 1; j++) {
next = curr.next;//以测试第一个用例为例子,这是第一次循环next=2
curr.next = next.next;//让1->3.定义0为头节点
next.next = prev.next;//让2->1
prev.next = next;//让0—>2,后面在循环一次一样的步骤
}
//改变变量节点到下一个需要逆转节点处
prev = curr;
curr = prev.next;
}
return dummy.next;
}
}