c语言就地逆置一条带头节点的单链表，头插法

假设链表的头节点为head，原链表为：head -> a -> b -> c -> d

1. 从头节点的下一个节点a开始，依次将每个节点插入到头节点head之后
2. 需要一个中间变量p来暂存当前节点的下一个节点，防止链表断裂

代码实现如下：

void reverseList(Node *head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    Node *p = head->next; // p指向第一个要插入的节点a
    head->next = NULL; // 将头节点的next指针置为空，防止链表断裂
    while (p != NULL) {
        Node *next = p->next; // 暂存下一个节点
        p->next = head->next; // 将p节点插入到头节点之后
        head->next = p;
        p = next; // p指向下一个节点，继续插入操作
    }
}

执行上述代码后，链表变为：head -> d -> c -> b -> a

相关问题

如何使用C语言中的算法来就地逆置一个带头结点的单链表？

在C语言中，要就地逆置一个带头结点的单链表，可以采用类似于上面伪代码的方式。下面是具体的步骤：

首先，我们需要定义一些必要的结构体来表示链表节点和头结点：

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

typedef struct List {
    ListNode* head;
} List;

接着，编写函数`reverseList`来实现逆置操作：

void reverseList(List* list) {
    ListNode* prev = NULL; // 初始化前驱节点
    ListNode* curr = list->head; // 初始化当前节点为头节点

    // 遍历整个链表
    while (curr != NULL) {
        ListNode* nextTemp = curr->next; // 保存当前节点的下一个节点
        curr->next = prev; // 将当前节点的next指向前一个节点
        prev = curr; // 更新前驱节点
        curr = nextTemp; // 移动到下一个节点
    }

    // 更新链表头
    list->head = prev;
}

最后，你可以像这样调用`reverseList`函数：

List yourList = { .head = malloc(sizeof(ListNode)) }; // 创建并初始化链表
// ... 添加节点到链表 ...

reverseList(&yourList); // 调用逆置函数

// ... 检查和使用逆置后的链表 ...

这个过程的时间复杂度是O(n)，其中n是链表的长度，因为它只遍历了一次链表。

用C语言写一算法对单链表实现就地逆置，代码必须编写单链表，完成代码中体现出单链表的插入，逆置等操作，输入一些数，直到输入文件结束为止，输出共一行表示，逆置后单链表中的元素

在C语言中，我们可以使用迭代的方式来实现单链表的就地逆置。首先，我们需要定义链表节点结构体，并创建一个头指针指向链表的开始。下面是完整的代码示例：

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

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

// 插入节点到链表
void insert(Node** head, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (!newNode) {
        printf("Memory allocation failed.\n");
        return;
    }
    newNode->data = value;
    newNode->next = *head;
    *head = newNode;
}

// 逆置链表
void reverseList(Node** head) {
    Node* prev = NULL;
    Node* current = *head;
    Node* nextTemp = NULL;
    
    while (current != NULL) {
        nextTemp = current->next;
        current->next = prev;
        prev = current;
        current = nextTemp;
    }
    *head = prev; // 更新新的头指针
}

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

int main() {
    Node* head = NULL;
    char input;

    // 读取输入并插入数字到链表
    while ((input = getchar()) != EOF) {
        if (input == '\n') continue; // 跳过换行符
        insert(&head, input - '0'); // 输入的是ASCII码，转换为整数
    }

    // 逆置链表
    reverseList(&head);

    // 输出逆置后的链表
    printList(head);

    return 0;
}

在这个代码中，我们首先通过`insert`函数向链表中添加数字，然后通过`reverseList`函数逆置链表，最后`printList`函数用于打印链表内容。