按k个元素一组反转链表

/*
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

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

 

示例 1：


输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：



输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
 

提示：
链表中的节点数目为 n
1 <= k <= n <= 5000
0 <= Node.val <= 1000
 

进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LEN 128

/**
 * Definition for singly-linked list.
 *  */

 typedef struct ListNode {
    int val;
    struct ListNode *next;
} NODE;

struct ListNode* reverseKGroup(struct ListNode* head, int k)
{
    struct ListNode newhead;
    struct ListNode *pre, *pfirst, *p, *post;
    int i;

     newhead.next = head;
    pre = &newhead;

    p = pfirst = pre->next;

    while (p != NULL) {
    
        for (i = 1; (i < k) && (p != NULL); i++) {
            p = p->next;
        }
        
        if (p == NULL) {
            break;
        }

        post = p->next;

        //reverse pfirst to p
        struct ListNode *p1, *p2, *p3;

        p1 = pfirst;
        p2 = p1->next;

        while (p2 != post) {
            p3 = p2->next;
            p2->next = p1;
            p1 = p2;
            p2 = p3;
        }

        pre->next = p1;
        pre = pfirst;
        
        pfirst->next = post;
        p = pfirst = post;
    }

    return newhead.next;
}

static NODE *construct_link(const char *in_str) 
{
    int len = strlen(in_str);

    if ((len <= 0) || (len >= MAX_LEN))
        return NULL;

    int pos = len - 1;
    NODE head;
    NODE *p = &head;

    for (pos = 0; pos < len; pos++) {
        NODE *tmp = (NODE *)malloc(sizeof(NODE));
        tmp->val = in_str[pos] - '0';
        tmp->next = NULL;

        p->next = tmp;
        p = tmp;        
    }

    return head.next;
}

static void output_link(const NODE *link)
{
    const NODE *p = link;

    while(p != NULL) {
        printf("%d", p->val);
        p = p->next;
    }
}

static void free_link(NODE *link)
{
    NODE *p = link;

    while(p != NULL) {
        NODE *tmp = p->next;
        free(p);
        p = tmp;
    }
}

int main(void)
{
    static char a_str[MAX_LEN];

    printf("please input a string number (could be large):\n");
    gets(a_str);

    NODE *alink = construct_link(a_str);
    printf("alink: ");
    output_link(alink);    
    printf("\n");

    NODE *clink = reverseKGroup(alink, 3);

    printf("clink: ");
    output_link(clink);    
    printf("\n");

    free_link(clink);

    return 0;
}