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

在C语言中，可以使用迭代的方式来解决这个问题。首先，我们需要定义一个链表节点结构体，然后创建两个指针，一个用于遍历原始链表，另一个用于构建新的链表。下面是一个简单的步骤描述：

1. 定义一个链表节点结构体：

typedef struct Node {
    int data;
    struct Node* next;
} Node;

2. 定义函数，接受链表的头节点作为参数：

Node* reverseBetween(Node* head, int m, int n);

其中，`m` 表示开始位置，`n` 表示结束位置（非包含）。

3. 函数内部实现：

Node* reverseBetweenHelper(Node* start, Node* end) {
    // 确保有反转的区间
    if (start == end || start == NULL || end == NULL) {
        return start;
    }

    Node* prev = start;
    Node* curr = start->next;

    while (curr != end && curr->next != end) {
        // 反转当前区间的节点
        Node* temp = curr->next;
        curr->next = prev;
        prev = curr;
        curr = temp;
    }

    // 将反转后的节点连接到正确的位置
    if (curr == end) {  // 如果到达了 end，直接将 start 接上
        prev->next = start;
    } else {
        prev->next = curr;  // 将反转后的节点指向 end 的下一个节点
        curr->next = end->next;  // 将 end 的下一个节点指向反转后的节点
    }

    return prev;  // 返回新链表的起始节点
}

Node* reverseBetween(Node* head, int m, int n) {
    // 处理边界条件，如果 m 或者 n 为 1，则不需要反转
    if (m == 1) {
        return head;
    }
    
    // 查找第 m 个节点
    Node* new_start = reverseBetweenHelper(head, head->next);
    // 继续查找第 n+1 个节点并反转它们
    Node* new_end = reverseBetweenHelper(new_start, head);

    return new_end;  // 返回新链表的头节点
}

4. 样例输入输出：

int main() {
    Node* head = createLinkedList({1, 2, 3, 4, 5, 6});  // 创建链表
    int m = 3;
    int n = 6;

    Node* result = reverseBetween(head, m, n);  // 反转链表
    printLinkedList(result);  // 打印结果链表

    return 0;
}

// 辅助函数：创建链表、打印链表
Node* createLinkedList(int arr[], int size) {
    // 创建链表...
}

void printLinkedList(Node* node) {
    // 打印链表...
}

注意：上述代码省略了一些辅助函数，如 `createLinkedList` 和 `printLinkedList`，你需要根据实际需求填充这些函数。同时，`reverseBetweenHelper` 中的链表反转操作假设链表长度大于等于 m + 1。