[力扣c语言实现]25. k个一组翻转链表

原题目连接

1. 题目描述

给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。

示例 :
给定这个链表：1->2->3->4->5
当 k = 2 时，应当返回: 2->1->4->3->5
当 k = 3 时，应当返回: 3->2->1->4->5

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

2.代码如下

//2018-12-06  思路：头插法，每插一段就移动一段，保证“头”一直在最后面
struct ListNode* reverseKGroup(struct ListNode* head, int k) {
    if(k==1||!head||!head->next)
    {
        return head;
    }
    typedef struct ListNode list;
    list* new_head=malloc(sizeof(list));
    list* preal = new_head;
    list* pnext;
    new_head->next = NULL;
    list* p=head;
    int len=0;
    while(p)
    {
        len++;
        p = p->next;
    }
    if(len<k)
    {
        return head;
    }
    int count = len/k;//求得需要头插的段数
    p = head;
    pnext = p->next;
    int  i =0;
    while(i<count)
    {   
        int j = 0;
        while(j<k&&p)
        {   
            p->next = new_head->next;
            new_head->next = p;
            if(pnext)//非常重要的边界条件
            {    
                p = pnext;
                pnext = pnext->next;
            }
            else
            {   
                return preal->next;
            }
            j++;
        }
        int l = k;
        while(l)
        {
            new_head = new_head->next;
            l--;
        }
        i++;
    }
//k<len的情况下，头插后还剩一个字段长度<k的链表，要将它接上
   list *ptemp=preal->next;
    while(ptemp->next!=NULL)
    {   
        ptemp = ptemp->next;
    }
    ptemp->next = p;
    return preal->next;
}

3.切割+反转+链接的做法

将任务分解为三步骤：
1.剪切
将原链表以K步长分隔并得到该子链表的首尾指针和下一链表的头指针
node *curlist(node *list,int k,node **tail)
list为当前被分隔出来的子链表的头指针，k为步长，*tail为当前被分隔出来的子链表的尾结点的指针，返回值为下一个链表的头指针。

2.翻转
将分隔出来的链表反转
void reverselist(node *list)
将list为头指针的链表反转

3.链接
将上一个被分隔出来且反转后的子链表的尾结点的next指向下一个被分隔出来且反转后的子链表的头节点

for循环操作的是链表可以被分隔为k个一段的链表的最大段数，如果链表长度刚好为k的整数倍，那么返回即可，如果还剩下一段长度小于k的子链表，则按照题意，链接上它即可。

//2021-04-22

typedef struct ListNode node;

//裁剪链表,得到其以list开头，长度为k的链表，*tail为其尾结点,pnewhead为下一条链表的新头节点
node *curlist(node *list,int k,node **tail)
{
    (*tail) = NULL;
    node *p = list;
    while (k > 1 && p)
    {
        p = p->next;
        --k;
    }
    if (p == NULL)
    {
        return p;
    }
    node *pnewhead = p->next;
    (*tail) = p;
    p->next = NULL;
    return pnewhead;
}

//反转单链表
void reverselist(node *list)
{
    node *pnewlist = NULL;
    node *ptmp = list;
    while (ptmp)
    {
        if (!pnewlist)
        {
            pnewlist = ptmp;
            ptmp = ptmp->next;
            pnewlist->next = NULL;
        }
        else 
        {
            node *p = ptmp->next;
            ptmp->next = pnewlist;
            pnewlist = ptmp;
            ptmp = p;
        }
    }
}

struct ListNode* reverseKGroup(struct ListNode* head, int k){
    int len = 0;
    node *ptmp = head;
    while (ptmp)
    {
        len++;
        ptmp = ptmp->next;
    }

    if (len <= 0)
    {
        return head;
    }

    int segment = len/k;//计算出需要反转的链表的段数
    node *pcurhead = head;
    node *pnexthead = NULL;
    node *pcurtail = NULL;

    node *plisthead = NULL;
    node *plisttail = NULL;
    for(int i = 0 ; i < segment;i++)
    {
        if (i == 0)
        {
            pnexthead = curlist(pcurhead,k,&pcurtail);
            
            reverselist(pcurhead);

            plisttail = pcurhead;
            plisthead = pcurtail;

            pcurhead = pnexthead;
        }
        else 
        {
            pnexthead = curlist(pcurhead,k,&pcurtail);
           
            reverselist(pcurhead);

            plisttail->next = pcurtail;

            plisttail = pcurhead;

            pcurhead = pnexthead;
        }
    }

    if (pnexthead)
    {
        plisttail->next = pnexthead;
    }
    
    return plisthead;
}