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

Subscribe to see which companies asked this question

主要是判断表头和表尾的位置，然后进行反转，表头必须是反转节点的前一个，这样保持链表的链接性，

表尾的判断需要保证后面的连接性，，，主要考察链表指针方面的链接性，

/**
 * 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)  
    {  
        return NULL;  
    }  
    ListNode* dummy = new ListNode(0);  
    dummy->next = head;  
    int count = 0;  
    ListNode* pre = dummy;  
    ListNode* cur = head;  
    while(cur != NULL)  
    {  
        count ++;  
        ListNode* next = cur->next;  
        if(count == k)  
        {  
            pre = reverse(pre, next);  
            count = 0;     
        }  
        cur = next;  
    }  
    return dummy->next;  
    }
     ListNode* reverse(ListNode* pre, ListNode* end)  
    {  
        if(pre==NULL || pre->next==NULL)  
            return pre;  
        ListNode* head = pre->next;  
        ListNode* cur = pre->next->next;  
        while(cur!=end)  
        {  
            ListNode* next = cur->next;  
            cur->next = pre->next;  
            pre->next = cur;  
            cur = next;  
        }  
        head->next = end;  
        return head;  
    }
};