将一个带头结点的数据域依次为 a1，a2，…，an（n≥3）的单链表的所有结点逆置， 即第一个结点的数据域变为 an，…，最后一个结点的数据域为 a1。用C语言编程实现以上功能要求。

可以使用三个指针分别指向当前遍历到的结点、该结点的前驱结点和该结点的后继结点，然后依次将当前结点的 next 指针指向前驱结点，然后将三个指针向后移动一个结点，循环直到遍历完整个链表。最后将原来的头结点指向新的尾结点即可。

下面是具体的代码实现：

void reverseList(Node* head) {
    if(head == NULL || head->next == NULL) {
        return;
    }
    Node *prev = NULL, *cur = head->next, *next = cur->next;
    while(next != NULL) {
        cur->next = prev;
        prev = cur;
        cur = next;
        next = next->next;
    }
    cur->next = prev;
    head->next = cur;
}

其中，Node 表示链表的结构体，包含数据域和指向下一个结点的指针 next。head 表示头结点，head->next 指向第一个数据结点。

相关问题

将一个带头结点的数据域依次为 a1，a2，…，an（n≥3）的单链表的所有结点逆置，即第一个 结点的数据域变为 an，…，最后一个结点的数据域为 a1。用C语言输出

可以使用头插法将链表逆置，具体实现如下：

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

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

void reverseList(struct Node **head) {
    struct Node *current = *head;
    struct Node *prev = NULL;
    struct Node *next = NULL;

    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }

    *head = prev;
}

void printList(struct Node *node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
}

int main() {
    struct Node *head = (struct Node *)malloc(sizeof(struct Node));
    head->data = -1;
    head->next = NULL;

    // 构造链表
    for (int i = 1; i <= 5; i++) {
        struct Node *node = (struct Node *)malloc(sizeof(struct Node));
        node->data = i;
        node->next = head->next;
        head->next = node;
    }

    printf("原链表：");
    printList(head->next);

    reverseList(&(head->next));

    printf("\n逆置后的链表：");
    printList(head->next);

    return 0;
}

输出结果为：

原链表：1 2 3 4 5 
逆置后的链表：5 4 3 2 1 

C语言中将一个带头结点的数据域依次为 a1，a2，…，an（n≥3）的单链表的所有结点逆置，即第一个 结点的数据域变为 an，…，最后一个结点的数据域为 a1。编程实现以上功能要求

可以按照以下步骤实现单链表的逆置：
1. 遍历链表，计算链表的长度n（不包括头结点）
2. 从头结点的下一个结点开始，依次将每个结点插入到头结点之后，直到链表的尾结点
3. 将原来的尾结点指向NULL，将头结点的下一个结点作为新的头结点

具体的实现代码如下：

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

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

// 创建链表
Node* createList(int n) {
    Node *head, *p, *pre;
    head = (Node*)malloc(sizeof(Node));  // 创建头结点
    pre = head;
    printf("请输入%d个整数：\n", n);
    for (int i = 0; i < n; i++) {
        p = (Node*)malloc(sizeof(Node));
        scanf("%d", &p->data);
        pre->next = p;
        pre = p;
    }
    pre->next = NULL;
    return head;
}

// 遍历链表
void traverseList(Node *head) {
    Node *p = head->next;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 逆置链表
void reverseList(Node *head) {
    Node *p = head->next, *q;
    head->next = NULL;  // 新的头结点
    while (p) {
        q = p->next;    // 记录下一个结点
        p->next = head->next;
        head->next = p; // 将p插入到头结点之后
        p = q;
    }
}

int main() {
    int n;
    printf("请输入链表的长度：");
    scanf("%d", &n);
    Node *head = createList(n);
    printf("原始链表：");
    traverseList(head);
    reverseList(head);
    printf("逆置后的链表：");
    traverseList(head);
    return 0;
}