LeetCode k个一组翻转链表 C++

题目描述

给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。

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

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明 :

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

分析

还是链表翻转的问题
就是没k个一组
在这k个里进行翻转
一个pre记录整个k个片段的前面，一个lat记录其后面
也就是，对片段 1->2->3 k=3翻转时
pre指向前面一个-1 lat指向4
-1->1->2->3->4
在翻转时，用cur记录当前翻转到哪一个，每次就将后一个翻转到最前面
也就是，第一步：
-1->2->1->3->4
第二步
-1->3->2->1->4
当cur==lat时，这k个node的翻转就结束了
用lpre和cur分别表示当前翻转涉及的两个node
一开始lpre = pre->next ; cur = lpre->next
则翻转一次的过程为：

lpre->next = cur->next  //连上待翻转点的后面
cur->next = pre->next  //翻到片段最前面
pre->next = cur
cur = lpre->next  //更新待翻转的node

在外层就记录每k个翻转一次，每次更新pre lat就好

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode * reverseK(ListNode * pre, ListNode * lat)
{
	ListNode * lpre = pre->next;
	ListNode * cur = lpre->next;
	while (cur != lat)
	{
		lpre->next = cur->next;
		cur->next = pre->next;
		pre->next = cur;
		cur = lpre->next;
	}
	return lpre;
}
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode * h = new ListNode(-1);
	h->next = head;
	ListNode * cur = head;
	int t = 1;
	ListNode * pre=h;
	while (cur != NULL)
	{
		if (t%k == 0) {
			pre = reverseK(pre, cur->next);
			cur = pre->next;
		}
		else
			cur = cur->next;

		t += 1;
	}
	return h->next;
    }
};