用C语言写链表的逆置头插法

### 回答1：
链表逆置头插法的C语言实现如下：

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

typedef struct node {
    int data;
    struct node *next;
} Node, *LinkList;

LinkList reverse(LinkList head) {
    Node *p, *q;
    p = NULL;
    while (head) {
        q = head->next;
        head->next = p;
        p = head;
        head = q;
    }
    return p;
}

int main() {
    int i;
    Node a[10];
    LinkList head, p;
    for (i = 0; i < 10; i++) {
        a[i].data = i;
        a[i].next = &a[i + 1];
    }
    a[9].next = NULL;
    head = &a[0];
    head = reverse(head);
    p = head;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    return 0;
}

### 回答2：
链表的头插法是将新节点插入链表的头部，逆置链表的头插法则是将原链表的节点从头到尾一个个取出，依次插入到一个新链表的头部。

在C语言中，链表节点的定义通常如下：

typedef struct Node {
    int data; // 节点数据
    struct Node* next; // 下一个节点的指针
} Node;

我们可以编写一个名为`reverseList`的函数来实现链表的逆置头插法，代码如下：

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

// 链表节点定义
typedef struct Node {
    int data; // 节点数据
    struct Node* next; // 下一个节点的指针
} Node;

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

// 逆置链表的头插法
Node* reverseList(Node* head) {
    Node* newHead = NULL; // 新链表的头指针
    Node* temp;

    while (head != NULL) {
        temp = head->next; // 保存下一个节点的指针
        head->next = newHead; // 将当前节点插入到新链表的头部
        newHead = head; // 更新新链表的头指针
        head = temp; // 移动原链表的指针到下一个节点
    }

    return newHead; // 返回逆置后的链表头指针
}

// 输出链表数据
void printList(Node* head) {
    Node* current = head;

    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }

    printf("\n");
}

int main() {
    Node* n1 = createNode(1);
    Node* n2 = createNode(2);
    Node* n3 = createNode(3);
    Node* n4 = createNode(4);

    n1->next = n2;
    n2->next = n3;
    n3->next = n4;

    printf("原链表：");
    printList(n1);

    Node* newHead = reverseList(n1);

    printf("逆置链表：");
    printList(newHead);

    return 0;
}

以上代码的输出结果为：

原链表：1 2 3 4 
逆置链表：4 3 2 1 

在这个例子中，原链表的节点1、2、3、4被逆置后的新链表的头部插入，得到的新链表的节点为4、3、2、1。

### 回答3：
链表的逆置是指将链表中的结点顺序颠倒。头插法逆置链表是一种常用的方法。假设链表的定义如下：

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

使用头插法逆置链表的步骤如下：

1. 初始化一个空链表newList，新链表的头结点指针为NULL。
2. 遍历原链表，逐个取出结点。
3. 对于每个取出的结点，创建一个新结点，并将新结点的值赋为取出结点的值。
4. 将新结点的next指针指向newList的头结点(原头结点的后继结点)。
5. 更新newList的头结点为新结点。
6. 重复步骤2-5直到原链表的所有结点都取出并插入到newList中。
7. 返回newList作为逆置后的链表。

以下是使用C语言实现链表逆置的代码示例：

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

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

struct Node* reverseList(struct Node* head)
{
    struct Node* newList = NULL;

    while(head != NULL)
    {
        struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
        newNode->data = head->data;
        newNode->next = newList;
        newList = newNode;
        head = head->next;
    }

    return newList;
}

int main()
{
    struct Node node1, node2, node3;
    struct Node* head;

    node1.data = 1;
    node2.data = 2;
    node3.data = 3;

    node1.next = &node2;
    node2.next = &node3;
    node3.next = NULL;

    head = &node1;

    printf("原链表：");
    struct Node* p = head;
    while(p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");

    head = reverseList(head);

    printf("逆置后的链表：");
    p = head;
    while(p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");

    return 0;
}

运行该程序会输出如下结果：

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

以上就是使用C语言实现链表逆置的头插法。