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;
    }
};