leetcode算法题25——K个一组翻转链表

K个一组翻转链表（困难）

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例

解题

思路一：这个题与之前两两交换链表中的节点很像，只是这次不再是相邻结点交换了，但思路都差不多一样，也是用三个指针来做，思路是先让pre指针指向头节点dummy，然后根据k的值对链表遍历，让cur指针指向第k个结点的下一个结点，比如对于-1->1->2->3->4->5，k=3来说，pre就指向-1，cur指向3，我们要做的就是翻转pre和cur之间的链表，使其变为-1->3->2->1->4->5，那么我们可以专门写一个函数来完成这个事情，那么每次只要固定好pre和cur，就可以调用这个函数来完成翻转的工作。
这个函数该怎么写呢？主要思路就是使用三个指针pre、last和cur，分别指向-1，1和2，然后每次都是把cur放到pre后面，让last的next指向cur的next就行了，比如当完成第一次翻转后，链表就变为了-1->2->1->3->4->5，这时我们的pre、last和cur分别对应的结点是-1、1和3，把cur的3放到pre后面，然后同样让last的next指向cur的next，链表就变为了-1->3->2->1->4->5，如果k为3，则本次翻转就结束了。
注意是思路要清晰，在纸上画个链表多写写就会发现规律。

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(!head || k==1) return head;
        ListNode *dummy=new ListNode(-1), *pre=dummy,*cur=head;
        dummy->next=head;
        for(int i=1;cur;++i){
            if(i%k==0){
                pre=fanzhuan(pre,cur->next);
                cur=pre->next;
            }
            else
            cur=cur->next;
        } 
        return dummy->next;
        
    }
    ListNode* fanzhuan(ListNode* pre,ListNode* next){
        ListNode *last=pre->next,*cur=last->next;
        while(cur!=next){
            last->next=cur->next;
            cur->next=pre->next;
            pre->next=cur;
            cur=last->next;
        }
        return last;
    }
};

方法二：与思路一相同，只不过放到了同一个函数中实现。首先遍历整个链表，统计出链表的长度，然后如果长度大于等于k，交换节点，当 k=2 时，每段只需要交换一次，当 k=3 时，每段需要交换2此，所以i从1开始循环，注意交换一段后更新 pre 指针，然后 num 自减k，直到 num<k 时循环结束，参见代码如下：

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode *dummy = new ListNode(-1), *pre = dummy, *cur = pre;
        dummy->next = head;
        int num = 0;
        while (cur = cur->next) ++num;
        while (num >= k) {
            cur = pre->next;
            for (int i = 1; i < k; ++i) {
                ListNode *t = cur->next;
                cur->next = t->next;
                t->next = pre->next;
                pre->next = t;
            }
            pre = cur;
            num -= k;
        }
        return dummy->next;
    }
};

思路三：也可以使用递归来做，用 head 记录每段的开始位置，cur 记录结束位置的下一个节点，然后调用 reverse 函数来将这段翻转，然后得到一个 new_head，原来的 head 就变成了末尾，这时候后面接上递归调用下一段得到的新节点，返回 new_head 即可，其实翻转链表的思想都是一样的

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode *cur = head;
        for (int i = 0; i < k; ++i) {
            if (!cur) return head;
            cur = cur->next;
        }
        ListNode *new_head = reverse(head, cur);
        head->next = reverseKGroup(cur, k);
        return new_head;
    }
    ListNode* reverse(ListNode* head, ListNode* tail) {
        ListNode *pre = tail;
        while (head != tail) {
            ListNode *t = head->next;
            head->next = pre;
            pre = head;
            head = t;
        }
        return pre;
    }
};