给定一个单链表 L1→L2→⋯→Ln−1→Ln，请编写程序将链表重新排列为 Ln→L1→Ln−1→L2→⋯。例如：给定L为1→2→3→4→5→6，则输出应该为6→1→5→2→4→3。用C语言

在C语言中，可以使用迭代的方式来解决这个问题，因为递归操作可能会导致栈溢出，对于大型链表不太合适。以下是使用迭代实现的示例：

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

// 定义链表节点结构体
typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;

// 创建新节点
ListNode* createNode(int val) {
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->val = val;
    newNode->next = NULL;
    return newNode;
}

// 将链表重新排列
ListNode* reverseKGroup(ListNode* head, int k) {
    ListNode dummy(0), *tail = &dummy;
    dummy.next = head;
    
    for (int i = 0; ; i++) {
        if (!head || !head->next) { // 如果到达链表结尾
            tail->next = head; // 将剩余部分接到原头
            break;
        }
        
        ListNode* start = head;
        for (int j = 0; j < k && head; j++, head = head->next) {
            head = head->next;
        }
        
        ListNode* end = head;
        for (int j = 0; j < k; j++) {
            ListNode* temp = end->next;
            end->next = start;
            start = start->next;
            end = temp;
        }
        
        tail->next = end; // 更新尾巴指向当前组的末尾
        tail = tail->next; // 尾巴向前移动到下一个组开始位置
    }
    
    return dummy.next;
}

// 打印链表
void printList(ListNode* node) {
    while (node) {
        printf("%d ", node->val);
        node = node->next;
    }
    printf("\n");
}

int main() {
    // 示例链表
    ListNode* L = createNode(1);
    L->next = createNode(2);
    L->next->next = createNode(3);
    L->next->next->next = createNode(4);
    L->next->next->next->next = createNode(5);
    L->next->next->next->next->next = createNode(6);

    int k = 3; // 需要反转的组大小
    ListNode* newL = reverseKGroup(L, k);
    printf("Reversed chain list: ");
    printList(newL);
    
    return 0;
}

在这个例子中，`reverseKGroup` 函数接受链表的头节点 `head` 和需要反转的组大小 `k`，然后通过两个指针 `start` 和 `end` 分别从原始链表和已反转的部分开始，逐步完成每个长度为 `k` 的组的逆转。

运行这段代码，你会得到期望的结果：6 1 5 2 4 3。