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

思路

（1）首先判断有多少段 K ，最后一段不足 K 的子链表不用翻转；

（2）分别记录前面一段的尾节点 pretail ，后面一段的翻转前头节点 bfhead 和翻转后头节点 afhead 。 

class Solution {  
public:  
    ListNode *reverseKGroup(ListNode *head, int k) {  
        // Start typing your C/C++ solution below   
        // DO NOT write int main() function   
        if(head==NULL || k<2)    
            return head;    
        int len = 0;    
        ListNode *tmp = head;    
        while(tmp) {    
            len++;    
            tmp = tmp->next;    
        }   
        if(k>len)  return head;  
        int seg = len/k;    
        ListNode *newhead = NULL;  
          
        ListNode *cur = head;     
        ListNode *pre = NULL;  
        ListNode *bfhead = NULL;  
        ListNode *pretail = NULL;
        while(seg) {      
            int count = k;  
            bfhead = cur;  
            pre = NULL;  
            while(count) {    
                pre = cur;    
                cur = cur->next;    
                count--;    
            }    
            pre->next = NULL;   
            
            ListNode *afhead = reverse(bfhead);  
            if(newhead==NULL)   
            {
                newhead = afhead;  
                pretail = bfhead;
            }
            else
            {
                pretail->next = afhead;   
                pretail = bfhead;
            }
            seg--;              
        }  
        pretail->next = cur;
        return newhead;            
    }  
      
    ListNode *reverse(ListNode *head) {    
        if(!head)  return NULL;    
        ListNode *pre = NULL;    
        ListNode *cur = head;    
        ListNode *nxt;    
        while(cur) {    
            nxt = cur->next;    
            cur->next = pre;    
            pre = cur;    
            cur = nxt;    
        }    
        return pre;        
    }    
  
}; 

 

如果额外申请一个 dump 空节点，方便很多：

 

class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (!head || k <= 1) return head;

        ListNode dummy(0);
        dummy.next = head;
        ListNode *pre = &dummy;

        int i = 0;
        while (head) {
            i++;
            if (i % k == 0) {
                pre = reverse(pre, head->next);                
                head = pre->next;
            } else {
                head = head->next;   
            }
        }

        return dummy.next;
    }

    ListNode *reverse(ListNode *pre, ListNode *next) {
        ListNode *last = pre->next;
        ListNode *cur = last->next;
        while (cur != next) {
            last->next = cur->next;
            cur->next = pre->next;
            pre->next = cur;

            cur = last->next;
        }
        return last;
    }
};

 

上一段代码的 reverse 返回翻转后的头结点，而这段代码返回翻转后的尾节点。