输入若干个不超过100的整数，建立单链表，然后将链表中所有结点的链接方向逆置，要求仍利用原表的存储空间。输出逆置后的单链表

### 回答1：
可以使用以下步骤实现：

1. 定义一个结构体表示链表节点，包含一个整数值和一个指向下一个节点的指针。

2. 读入若干个整数，每读入一个整数就创建一个新的节点，并将其插入到链表的头部。

3. 定义两个指针prev和curr，分别指向链表头和第二个节点。

4. 依次遍历链表，将每个节点的next指针指向前一个节点，即将链表的方向逆置。

5. 最后将链表头指针指向prev，即为逆置后的链表头。

以下是示例代码：

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

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode *prev = NULL, *curr = head;
    while (curr != NULL) {
        struct ListNode *next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

int main() {
    struct ListNode *head = NULL;
    int n, x;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        struct ListNode *node = (struct ListNode*)malloc(sizeof(struct ListNode));
        node->val = x;
        node->next = head;
        head = node;
    }
    head = reverseList(head);
    while (head != NULL) {
        printf("%d ", head->val);
        head = head->next;
    }
    return 0;
}

### 回答2：
单链表是由一个个结点连接组成的，每个结点都包括一个数据域和一个指向下一个结点的指针，当我们需要对链表进行遍历或者操作的时候，就要利用这些指针来找到相应的结点并进行处理。

本题要求将单链表中所有结点的链接方向逆置，并且要利用原表的存储空间，即不能重新创建一个新的链表。这时我们可以利用三个指针分别指向当前结点、上一个结点和下一个结点，然后将当前结点的指针指向上一个结点，再依次移动三个指针，直到遍历完整个链表，最后将原来的表头指针指向逆置后的表尾结点。

具体实现过程如下：

1. 先输入若干个不超过100的整数，建立单链表。创建一个指针p指向头结点，并给头结点赋值为0。
2. 利用循环语句输入整数，并利用malloc函数为每个结点动态分配空间，并用scanf函数输入结点的值。将每个结点与前一个结点通过指针相连。
3. 利用三个指针n、prev和next分别指向当前结点、上一个结点和下一个结点。初始状态下，n指向头结点的下一个结点，prev指向头结点，next指向n的下一个结点。
4. 将当前结点n的指针指向上一个结点prev，然后依次移动三个指针，n指向next，next指向n的下一个结点，prev指向n。
5. 当next为NULL时，即到达链表尾部，将头结点的指针指向prev，即可完成链表逆置。
6. 最后利用循环语句遍历链表，并利用printf函数输出每个结点的值。

完整代码如下：

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

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

LinkList createList(int n);   // 建立单链表
LinkList reverseList(LinkList head);  // 链表逆置

int main()
{
    int n;
    printf("请输入链表中节点的个数：");
    scanf("%d", &n);

    LinkList head = createList(n);   // 建立链表
    printf("原链表：");

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

    head = reverseList(head);   // 链表逆置
    printf("逆置后的链表：");

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

    return 0;
}

LinkList createList(int n){
    LinkList head, p, q;
    head = (LinkList)malloc(sizeof(Node));
    head->next = NULL;
    q = head;
    for (int i = 0; i < n; i++){
        p = (LinkList)malloc(sizeof(Node));
        scanf("%d", &p->data);
        q->next = p;
        q = p;
    }
    q->next = NULL;
    return head;
}

LinkList reverseList(LinkList head){
    Node *prev, *n, *next;
    prev = NULL;
    n = head->next;
    while (n != NULL){
        next = n->next;
        n->next = prev;
        prev = n;
        n = next;
    }
    head->next = prev;
    return head;
}

上述代码可以实现输入若干个不超过100的整数，建立单链表，并将链表中所有结点的链接方向逆置，最后输出逆置后的单链表。

### 回答3：
题目要求输入一些整数，然后以这些整数建立单链表，并将链表中的节点连接方向逆置，最后输出逆置后的单链表。这道题需要注意链表的建立和链接方向的调整。

首先，我们需要定义一个链表节点的结构体，包含一个整数data和一个指向下一个节点的指针next：

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

然后，我们可以按照输入的顺序来建立链表。假设输入的整数保存在一个数组nums中，那么我们可以这样建立链表：

ListNode *head = new ListNode();  // 创建头结点
ListNode *tail = head;  // 尾指针指向头结点
for (int i = 0; i < n; i++) {
    ListNode *node = new ListNode();
    node->data = nums[i];
    tail->next = node;
    tail = node;
}
tail->next = NULL;  // 尾节点指针置空

这里，我们创建了一个头结点head和尾指针tail，然后循环遍历输入的整数，为每个整数创建一个节点node，并将该节点链接到尾节点的next指针上。最后，我们需要将尾节点的next指针置空，表示链表的结尾。

接下来，我们需要将链表中的节点链接方向逆置。这一步可以使用三个指针来实现，分别是当前节点p、前驱节点pre和后继节点succ。初始时，pre和p指向头结点，succ指向p的后继节点。然后顺序遍历链表，将p的next指针指向pre，然后依次将pre、p、succ指针向后移动一个节点，即pre=p, p=succ, succ=succ->next。直到遍历完整个链表，最后将头结点的next指针指向逆置后的链表的第一个节点。

ListNode *pre = head;
ListNode *p = head->next;
ListNode *succ = p->next;
while (succ != NULL) {
    p->next = pre;
    pre = p;
    p = succ;
    succ = succ->next;
}
head->next = p;  // 头结点的next指向逆置后的链表的第一个节点

最后，我们可以按顺序输出逆置后的链表中所有节点的data值：

ListNode *node = head->next;
while (node != NULL) {
    cout << node->data << " ";
    node = node->next;
}

综上，这道题需要理解链表的建立和节点链接方向的操作，同时需要注意指针的移动和链表首尾节点的处理。