LeetCode Reverse Nodes in k-Group

最新推荐文章于 2025-05-21 19:43:17 发布

原创最新推荐文章于 2025-05-21 19:43:17 发布 · 468 阅读

0 ·

CC 4.0 BY-SA版权

面试题专栏收录该内容

144 篇文章

订阅专栏

本文介绍了一种算法，该算法将给定链表中的节点每K个一组进行翻转，并返回修改后的链表。文章详细解释了当节点数量不是K的倍数时如何处理剩余节点，并强调了算法中只允许改变节点本身而不能改变节点值的要求。

题目：

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,
Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

/**
 * 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) {
		if (head == NULL || k <= 1)
			return head;
		int s = 0;
		ListNode *dummy = new ListNode(-1);
		ListNode *tail = dummy;
		ListNode *h1 = head;
		ListNode *cur = head;
		while (1) {
			while (cur != NULL && s != k) {
				cur = cur->next;
				s++;
			}
			//可以构成一组，对链表进行反转
			if (s == k) {
				//下一组的头
				ListNode *h2 = cur;
				ListNode *p = h1;
				ListNode *q = h1->next;
				while (q != h2) {
					ListNode *r = q->next;
					q->next = p;
					p = q;
					q = r;
				}
				tail->next = p;
				tail = h1;
				s = 0;
				h1 = h2;
				cur = h2;
			}
			else {
				tail->next = h1;
				break;
			}
		}
		ListNode *newHead = dummy->next;
		delete dummy;
		return newHead;
	}
};