给我完整的代码c语言给定一个单链表 L1→L2→⋯→Ln−1→Ln，请编写程序将链表重新排列为 L3→⋯ Ln→L1→L2。 样例输入 1 2 3 4 5 6 样例输出 3 4 5 6 1 2

在C语言中，我们可以使用迭代的方式来解决这个问题，因为链表遍历通常是线性的，我们只需要存储两个指针，一个指向当前节点，另一个指向下一个节点，然后在每个节点处理完后移动这两个指针。下面是一个简单的示例代码：

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

// 定义链表结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node;

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

// 交换链表节点
void reverseBetween(Node** head, int m) {
    if (*head == NULL || m <= 1)
        return;

    Node* prev = *head;
    Node* current = *head->next;
    Node* nextTemp = NULL;

    // 如果m > 2，需要额外处理头结点
    if (m > 2) {
        for (int i = 0; i < m - 2; i++) {
            nextTemp = current->next;
            current->next = prev;
            prev = current;
            current = nextTemp;
        }
    }

    // 然后直接反转剩余部分
    while (current != NULL) {
        nextTemp = current->next;
        current->next = prev;
        prev = current;
        current = nextTemp;
    }

    // 合并两部分链表
    prev->next = *head;
    *head = current;
}

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

int main() {
    // 示例输入
    int values[] = {1, 2, 3, 4, 5, 6};
    int n = sizeof(values) / sizeof(values[0]);

    // 构建链表
    Node* head = NULL;
    for (int i = 0; i < n; i++) {
        Node* newNode = createNode(values[i]);
        if (head == NULL) {
            head = newNode;
        } else {
            Node* temp = head;
            while (temp->next != NULL) {
                temp = temp->next;
            }
            temp->next = newNode;
        }
    }

    printf("Original list:\n");
    printList(head);

    // 反转特定范围的节点
    reverseBetween(&head, 3); // 只反转从第三个节点开始

    printf("Reversed list:\n");
    printList(head);

    return 0;
}

运行这个代码后，它会创建一个链表，然后按照指定的方式重新排列，并打印出结果。