编写一个函数，实现单链表就地逆置

好的，以下是实现单链表就地逆置的函数代码：

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

这个函数会将传入的单链表就地逆置，即不需要创建新的链表，只需要修改原链表中节点的指向关系即可。

相关问题

用C语言编写一个实现带头结点单链表就地逆置的一个程序。在编写该程序时，要求单独写一个函数来实现单链表的逆置，并编写代码在main函数测试结果

好的，您的第一个问题是使用C语言编写一个带头结点单链表就地逆置的程序。我可以回答这个问题。以下是示例代码：

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

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

// 初始化链表
void init(Node** head) {
    *head = (Node*)malloc(sizeof(Node));
    (*head)->next = NULL;
}

// 将新节点插入到链表末尾
void insert(Node* head, int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = data;
    new_node->next = NULL;

    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = new_node;
}

// 遍历链表并输出节点数据
void traverse(Node* head) {
    Node* temp = head->next;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

// 单链表就地逆置
void reverse(Node* head) {
    Node* prev = NULL;
    Node* cur = head->next;
    Node* next = NULL;

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

int main() {
    Node* head = NULL;
    init(&head);

    // 插入节点
    insert(head, 1);
    insert(head, 2);
    insert(head, 3);
    insert(head, 4);
    insert(head, 5);

    printf("原始链表：");
    traverse(head);

    // 单链表就地逆置
    reverse(head);

    printf("逆置后的链表：");
    traverse(head);

    return 0;
}

您可以将这段代码保存为一个.c文件，在命令行中使用gcc编译运行。如果需要更多帮助，请告诉我。

本题目要求编写一个实现带头结点单链表就地逆置的一个程序。在编写该程序时，要求单独写一个函数来实现单链表的逆置，并编写代码在main函数测试结果。

好的，我明白您的问题了。下面是程序代码：

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

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

void printList(Node* head) {
    Node* cur = head->next;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
}

void reverseList(Node* head) {
    Node* pre = head->next;
    Node* cur = pre->next;
    Node* next = cur->next;
    pre->next = NULL;

    while (next != NULL) {
        cur->next = pre;
        pre = cur;
        cur = next;
        next = next->next;
    }
    cur->next = pre;
    head->next = cur;
}

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

    // 创建带头结点单链表
    Node* p = head;
    for (int i = 1; i <= 5; i++) {
        Node* node = (Node*)malloc(sizeof(Node));
        node->data = i;
        node->next = NULL;
        p->next = node;
        p = node;
    }

    // 输出初始链表
    printf("初始链表：");
    printList(head);

    // 链表逆置
    reverseList(head);

    // 输出逆置后链表
    printf("逆置后链表：");
    printList(head);

    return 0;
}

运行结果：

初始链表：1 2 3 4 5 
逆置后链表：5 4 3 2 1