[Leetcode] Reverse nodes in k group 每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

 题意：以k个结点为一组，进行反转连接，若最后小于k个结点，则保持不变。要求：仅用常数空间，不改变结点的值。

思路：大致过程是每k个结点一反转，直到剩余结点数小于k。遇到一个问题是：如何判断剩余结点数小于k，即循环的终止条件？这样就需要知道整条链表的总共的结点数count，然后每次反转完一组则用总的count减去k，直到最后剩余结点数小于k，就不用改变。遇到另一个问题，如何反转k个结点，这个和reverse linked list ii类似，大致的想法可以参照。这样就剩下的如何将不同的小组连接起来的问题，因为在reverse linked list ii这题中，只要反转一部分，所以其pre是不动的，这题因为有很多小组，所以pre应该是每k个结点为一小组的最开始结点的前驱，所以要移动，同理的是当前节点cur。因为要改变表头，所以要先new一个nList。使用计数器的思维值得注意。

/**
 * 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 *nList=new ListNode(-1);
        nList->next=head;
        ListNode *cur=head;
        ListNode *pre=nList;

        int num=0;      //组里的结点数
        int count=0;    //整链结点数
        while(head)
        {
            head=head->next;
            count++;
        } 

        while(count>=k)     //整体遍历
        {
            while(++num<k)  //组内循环
            {
                ListNode *temp=cur->next;
                cur->next=temp->next;
                temp->next=pre->next;
                pre->next=temp;
            }
            count-=num;　　//减k也行.
            num=0;
            pre=cur;    //每组反转以后，pre要移动
            cur=cur->next;  //cur要变
        }
        return nList->next;

    }
};

 

还有另一种写法：见Code Gander的博客，其核心思想是，每次取k个结点进行反转，传入反转函数的是这个组的前驱和其最后一个结点，反转函数返回是反转后小组的第一个结点，体会其中的差别。代码如下：

/**   Reverse Nodes in k-Group 
 *
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */                 //经典，很多关于list的题都可用这种方法重写
 /* 使用计数器count，若count=k，则反转前k个节点，然后重置count */
class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) 
    {
        if(head==NULL)  return NULL;

        ListNode *preAll=new ListNode(-1);
        preAll->next=head;

        ListNode *pre=preAll;
        ListNode *cur=head;
        int count=0;

        while(cur !=NULL)
        {
            count++;
            ListNode *last=cur->next;
            if(count==k)
            {
                pre=reverse(pre,last);
                count=0;
            }
            cur=last;
        } 

        return preAll->next;   
    }

    //反转前k个节点，这k个点的前驱和最后一点传入
    ListNode *reverse(ListNode *pre,ListNode *last)
    {
        if(pre==NULL||pre->next==NULL)  return pre;

        ListNode *head=pre->next;
        ListNode *cur=pre->next->next;

        while(cur !=last)
        {
            ListNode *temp=cur->next;
            cur->next=pre->next;
            pre->next=cur;
            cur=temp;
        }

        head->next=last;
        return head;    //巧妙之处是返回前节点
    }
};