给出一个链表,每 k 个节点一组进行翻转,并返回翻转后的链表。
k 是一个正整数,它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍,那么将最后剩余节点保持原有顺序。
示例 :
给定这个链表:1->2->3->4->5
当 k = 2 时,应当返回: 2->1->4->3->5
当 k = 3 时,应当返回: 3->2->1->4->5
说明 :
你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
//涉及到链表指针的题目大多需要进行链的翻转,如下会用一个常用的
1、
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode* pre;
ListNode* p = head;
ListNode* q = head;
if(!p || k == 1) return p;
for(int i = 1; i < k; i ++){
if(!q->next) return head;
q = q->next;
}
pre = p;
head = q;
while(p->next != head){//翻转链表的核心
q = p->next; //1. 缓冲p后面的单链表
p->next = p->next->next; //2. 反转单链表
q->next = pre; //3.让pPre指针后移
pre = q; //4. 让pre指针后移
}
p->next = reverseKGroup(head->next, k);
head->next = pre;
return head;
}
};
2、
public ListNode reverseKGroup(ListNode head, int k) {
if(head == null)
{
return null;
}
ListNode dummy = new ListNode(0);
dummy.next = head;
int count = 0;
ListNode pre = dummy;
ListNode cur = head;
while(cur != null)
{
count ++;
ListNode next = cur.next;
if(count == k)
{
pre = reverse(pre, next);
count = 0;
}
cur = next;
}
return dummy.next;
}
private ListNode reverse(ListNode pre, ListNode end)
{
if(pre==null || pre.next==null)
return pre;
ListNode head = pre.next;
ListNode cur = pre.next.next;
while(cur!=end)
{
ListNode next = cur.next;//缓冲cur后面的链表
cur.next = pre.next;//翻转单链表
pre.next = cur;//让pre.next的指针后移,类似于后移head
cur = next;//后移cur的指针
}
head.next = end;
return head;
}
//直接翻转单链表
ListNode *listReverse(ListNode *pHead)
{
if(pHead == NULL)
return NULL;
ListNode *pCurrent ,*pPre,*pNext;
//一、指针的初始化阶段
pPre = pHead;
pCurrent = pPre->next ;
while(pCurrent) //二、反转单链表的核心代码
{
pNext = pCurrent->next ; //1. 缓冲pCurrent后面的单链表
pCurrent->next = pPre ; //2. 反转单链表
pPre = pCurrent; //3.让pPre指针后移
pCurrent = pNext ; //4. 让pCurrent指针后移
}
//三、处理并返回头指针
pHead->next = NULL; //把原头结点的next域变成空指针
pHead = pPre ; //把头结点指向最后一个结点产生新的头结点,也就是把原单链表的尾结点变成头结点
return pHead;
}