LeetCode k个一组翻转链表

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

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

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

示例：

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

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

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

说明：

你的算法只能使用常数的额外空间。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
/***需要了解**：
pair是将2个数据组合成一组数据，当需要这样的需求时就可以使用pair，
如stl中的map就是将key和value放在一起来保存。
另一个应用是，当一个函数需要返回2个数据的时候，可以选择pair。 
pair的实现是一个结构体，主要的两个成员变量是first second 
因为是使用struct不是class，所以可以直接使用pair的成员变量。

其标准库类型--pair类型定义在#include <utility>头文件中

myreverse函数功能：实现链表的逆置，采用头插法
设置一个指针node，遍历链表将链表中的结点都依次插入到node的后面，从而实现链表的翻转，最后返回一个pair类型*/
    pair<ListNode*,ListNode*> myreverse(ListNode *head,ListNode *tail,int k){
        ListNode *p=head,*t;
        int n=1;
        ListNode *node=new ListNode();
        node->next=nullptr;
        while(p&&n<=k){
            t=p->next;
            p->next=node->next;
            node->next=p;
            p=t;
            n++;
        }
        return {tail,head};

    }
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode *p;int len=0;
        p=head;
        //链表为空或者只有一个结点，直接返回head
        if(head==NULL||head->next==NULL)
            return head;
            //计算链表的长度
        while(p!=NULL){
            len++;
            p=p->next;
        }
        int yushu,n=1;
        //计算余数，那么需要处理的结点个数是len-yushu，每次处理k个结点，则需要处理的次数是（len-yushu）/k
        yushu=len%k;
        p=head;
        ListNode *pre,*nex,*node=new ListNode();
        node->next=head;
        ListNode *tail;
        while(p!=NULL&&n<=(len-yushu)/k){
                tail=p;
                for(int i=0;i<k-1;i++){
                    tail=tail->next;
                }
                nex=tail->next;
           // p为这组链表的头结点，tail为这组链表的尾结点
          // pair<ListNode*,ListNode*>result=myreverse(p,tail,k);
          // n为1时，说明处理的这组链表是初始链表的前k个结点，head需要改变，
          //并且pre指针也变为这组结点翻转后的尾结点

           if(n==1){
               head=result.first;
               pre=result.second;
           }
            else{
                pre->next=result.first;
            } 
           result.second->next=nex;
            pre=result.second;
            n++;
            p=nex;

        }
        return head;
    }
};