LeetCode: Reverse Nodes in k-Group [024]

【题目】

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个节点，剩下的节点扔给下一个递归迭代来完成。

注意集中特殊情况：
            1. 链表为空
            2. 链表只有1个节点
            3. K=1, 此时不需要做任何处理
            4. K大于链表长度

【代码】

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode*reverse(ListNode*head){
        if(head==NULL)return head;
        if(head->next==NULL)return head;
        ListNode*prev=NULL;
        ListNode*cur=head;
        ListNode*next=NULL;
        while(cur){
            next=cur->next;
            cur->next=prev;
            prev=cur;
            cur=next;
        }
        return prev;
    }
    ListNode*reverseLink(ListNode*head, int k){
        if(head==NULL)return head;
        int count=1;
        ListNode*p=head;
        ListNode*nextHead=NULL;
        while(p->next&&count<k){p=p->next;count++;}
        if(count<k)return head;     //已经不满K个节点了，直接返回
        nextHead=p->next;
        p->next=NULL;
        reverse(head);
        head->next=reverseLink(nextHead,k);
        return p;
    }
    ListNode *reverseKGroup(ListNode *head, int k) {
        if(head==NULL)return head;
        if(head->next==NULL)return head;
        if(k==1)return head;
        return reverseLink(head,k);
    }
};