LeetCode 025. Reverse Nodes in k-Group

Reverse Nodes in k-Group

 

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

可以说上一道题 Swap Nodes in Pairs是这一道题的特例，这两道题无非都是指针操作。

在操作过程中要非常注意的一点是小心会因为a->nex=b并且b->next=a而出现死循环的情况！

代码如下：

/**
 * 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(k == 1 || !head)
            return head;
            
        ListNode *p, *q, *temp;
        ListNode * rear = head;
        ListNode * fore = head;
        int num = 0;        
        int firsttime = true;
        
        while(true)
        {
            //判断是否存在k个节点
            num = 0;
            temp = fore; //记录本组的首节点地址
            while(fore)
            {
                num ++;
                if(num == k)
                {
                    if(firsttime)
                    {
                        head = fore;
                        firsttime = false;
                    }
                    else
                    {
                        rear->next = fore;  //上一组元素尾节点指向本组元素首节点
                        rear = temp;        //rear指向本组首节点
                    }
                    break;
                }
                fore = fore->next;
            } 
            //不存在k个节点，则上一组元素的rear指向本组元素首节点
            if(num < k)
            {
                if(!firsttime)          //加上条件，防止出循环队列
                    rear->next = temp;
                break;
            }
            
            fore = fore->next; //指向一下组元素的首节点
            
            //旋转操作    
            p = rear;
            q = rear->next;
            if(rear->next)
                temp = rear->next->next;
            else
                temp = NULL;
            num = 0;
            while(num < k-1)  //只需要进行k-1次转换
            {
                q->next = p;
                p = q;
                q = temp;
                if(temp)
                    temp = temp->next;
                num ++;
            }
        }
        return head;
    }
};