leetcode K个一组反转链表

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

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

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

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明 :

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解：

首先实现链表反转函数。然后没找到k个节点，进行反转。

参考代码：

/**
 * 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) {
        //特殊情况：NULL或仅有一个节点
        if(head == nullptr || head->next == nullptr)
            return head;

        //虚拟头结点
        ListNode *dummyHead = new ListNode(0);
        dummyHead->next = head;

        //next指向当前结点的下一个结点
        ListNode *next = head;
        //pre_tail指向上一段链表的尾节点，初始值为空指针
        ListNode *pre_tail = nullptr;
        //每一个段的头结点
        ListNode *newHead = head;
        //计数值，当count增加到k时，就断链，倒置，挂链
        int count = 0;

        while(head){
            count++;
            next = head->next;
            if(count == k){
                //断链，并且将该小段链表送入倒置函数中
                head->next = nullptr;
                HeadTail headTail = reverse(newHead);

                //挂链：处理倒置后的链表的头和尾，巧妙利用pre初始值是否为空
                if(pre_tail)
                    //不为空，则上一段链表尾节点指向新置链表头结点
                    pre_tail->next = headTail.head;
                else
                    //为空，则虚拟头结点指向新置链表头结点
                    dummyHead->next = headTail.head;

                headTail.tail->next = next;

                //更新上一段链表的尾节点、下一段链表的头结点和计数值count
                pre_tail = headTail.tail;
                newHead = next;
                count = 0;//别忘记计数值重置
            }
            
            head = next;
        }
        return dummyHead->next;//dummyHead大法好
    }

    //链表的头和尾结构体
    struct HeadTail{
        ListNode *head;
        ListNode *tail;
    };

    //reverse函数返回两个参数：倒置后的链表头和尾
    HeadTail reverse(ListNode* head){
        //巧妙使用pre指针，初始值为空
        ListNode *pre = nullptr;
        ListNode *cur = head;
        ListNode *next = head;
        while(cur){
            next = cur->next;
            //pre初始值为空
            cur->next = pre;
            //更新pre值，很巧妙
            pre = cur;
            cur = next;
        }
        HeadTail headTail;
        headTail.head = pre;
        headTail.tail = head;

        return headTail;
    }
};