K 个一组翻转链表

难度：困难

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

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

 

示例：

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

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

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

 

说明：

• 你的算法只能使用常数的额外空间。（这边可以理解为空间复杂度要达到O(1)）
• 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

 

题目解析：

       https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/k-ge-yi-zu-fan-zhuan-lian-biao-by-leetcode-solutio/

 

参考代码：

     

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <list>
#include <unordered_map>
#include <cstring>
#include <map>
#include <stdexcept>

using namespace std;

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
	ListNode* reverseKGroup(ListNode* head, int k) {
		if (head == NULL)
			return NULL;

		ListNode temp_head = ListNode(0);
		temp_head.next = head;
		ListNode* pre = &temp_head;
		ListNode* tail = pre;
		
		while (head)
		{
			//看看剩余的节点数够不够K个，够的话将tail指向第K个节点
			for (int i = 0; i < k; i++)
			{
				tail = tail->next;
				//不满足条件，后面的几个节点也不需要反转
				if (tail == NULL)
					return temp_head.next;
			}
			ListNode* prev = tail->next;  //记录tail节点的下一个节点，后边要链接
			pair<ListNode*, ListNode*> data;
			data = my_reverse(head,tail); //使用data来记录反转过后的头结点和尾结点
			head = data.first;
			tail = data.second;

			//连接起来
			pre->next = head;//上一个已经反转好的尾结点（pre），与现在刚反转好的头结点链接
			tail->next = prev;//现在刚反转好的尾结点链接下面没有反转的头结点
			//移动下两个节点，准备下次反转
			pre = tail;
			head = prev;
		}
		return temp_head.next;
	}

	pair<ListNode*, ListNode*> my_reverse(ListNode* head, ListNode* tail)
	{
		ListNode* prev = tail->next;
		ListNode* pMove = head;
		while (prev != tail)
		{
			ListNode* next = pMove->next;
			pMove->next = prev;
			prev = pMove;
			pMove = next;
		}
		return{ tail, head };
	}
};

int main()
{
	Solution solution;
	ListNode* ListNode1 = new ListNode(1);
	ListNode* ListNode2 = new ListNode(2);
	ListNode* ListNode3 = new ListNode(3);

	ListNode* ListNode4 = new ListNode(4);
	ListNode* ListNode5 = new ListNode(5);
	ListNode* ListNode6 = new ListNode(6);

	ListNode* ListNode7 = new ListNode(7);
	//	ListNode* ListNode8 = new ListNode(8);
	//ListNode* ListNode9 = new ListNode(10);
	//ListNode* ListNode10 = new ListNode(11);

	ListNode1->next = ListNode2;
	ListNode2->next = ListNode3;
	ListNode3->next = ListNode4;

	ListNode4->next = ListNode5;
	ListNode5->next = ListNode6;
	ListNode6->next = ListNode7;

	ListNode7->next = NULL;
	//	ListNode8->next = NULL;
	//lists.push_back(ListNode1);
	//lists.push_back(ListNode4);
	//	lists.push_back(ListNode7);
	ListNode* res = solution.reverseKGroup(ListNode1,3);

	while (res)
	{
		cout << res->val << endl;
		res = res->next;
	}
	system("pause");
	return 0;
}