输入若干个正整数（输入-1为结束标志），要求按输入数据的逆序建立一个链表，并输出。 输入输出示例： 1 2 3 4 5 6 7 -1 7 6 5 4 3 2 1

以下是 Python 代码实现：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

head = None
while True:
    num = int(input())
    if num == -1:
        break
    new_node = ListNode(num)
    new_node.next = head
    head = new_node

# 遍历链表并输出
while head:
    print(head.val, end=' ')
    head = head.next

输入样例：

1
2
3
4
5
6
7
-1

输出样例：

7 6 5 4 3 2 1

相关问题

输入若干个正整数（输入-1为结束标志），要求按输入数据的逆序建立单链表并输出。

### 回答1：
题目描述：

输入一些正整数，以-1为结束标志，要求按照输入数据的逆序建立单链表，并输出。

解题思路：

1. 定义链表节点结构体，包含数据域和指针域。

2. 定义头节点指针，初始化为NULL。

3. 循环读入正整数，直到读入-1为止。

4. 每读入一个正整数，就新建一个节点，将该正整数存入节点的数据域中，将该节点插入到链表的头部。

5. 循环输出链表中的每个节点的数据域。

代码实现：

### 回答2：
题目要求我们按照输入数据的逆序建立单链表并输出，那我们可以这样做：

首先，我们声明一个结构体用来表示一个链表节点，这个节点包含两个域，一个是int类型的data用来存储数据，一个是指向下一个节点的指针next。

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

接着，我们定义一个头指针head，一个尾指针tail，以及一个计数器count用来统计输入的数据个数。

struct ListNode *head, *tail;
int count = 0;

然后，我们通过一个循环来读取输入数据，每读入一个数据，我们就创建一个新节点，存储数据并将其插入链表的头部。

int num;
head = NULL;
tail = NULL;
while(1)
{
    scanf("%d", &num);
    if(num == -1)
        break;
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->data = num;
    node->next = head;
    head = node;
    if(tail == NULL)
        tail = node;
    count++;
}

最后，我们按照逆序输出链表中的数据，只需从链表的头部开始循环遍历，遍历到每个节点时输出该节点存储的数据即可。

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

至此，问题得到解决。完整代码如下：

### 回答3：
这道题目要求我们输入一些正整数，然后将它们按照输入的逆序建立单链表，并输出。对于这道题目，我们可以先考虑需要用到哪些数据结构来解决它。

首先，我们需要一个单链表来存储输入的正整数，因为单链表可以动态地添加元素，并且它可以很方便地实现逆序排列，正如这道题的要求。同时，我们需要一个整型变量来存储输入的正整数，以及一个计数器来记录输入了多少个正整数。

接着，我们需要进行输入，如果输入的数字不为 -1，就将其加入单链表中，并将计数器 +1；如果输入为 -1，则停止输入。

最后，我们需要将单链表逆序输出。逆序输出单链表可以通过递归实现，对单链表中的每个节点进行递归调用，先输出当前节点之后的节点，然后再输出当前节点。这样，就可以将单链表逆序输出。

总结一下，这道题目输入若干个正整数，建立单链表并按照逆序输出的过程可以分为三个步骤。首先，输入正整数，将其加入单链表，并记录计数器。其次，递归地输出单链表中的节点。最后，输出全部完成。

用C语言编写：输入若干个正整数（输入-1 为结束标志），按输入的逆序建立一个单向链表，并输出链表。

好的，以下是用 C 语言编写的程序，实现您的要求：

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

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

int main() {
    struct Node* head = NULL;
    
    // 循环读入并建立链表
    int num;
    printf("请输入若干个正整数，以-1作为结束标志：\n");
    scanf("%d", &num);
    while (num != -1) {
        struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
        newNode->val = num;
        newNode->next = head;
        head = newNode;
        
        scanf("%d", &num);
    }
    
    // 遍历链表，输出结果
    printf("链表的逆序为：\n");
    struct Node* p = head;
    while (p != NULL) {
        printf("%d ", p->val);
        p = p->next;
    }
    printf("\n");
    
    // 释放链表结点的内存
    p = head;
    while (p != NULL) {
        struct Node* tmp = p;
        p = p->next;
        free(tmp);
    }
    head = NULL;

    return 0;
}

上述程序中，我们同样定义了一个结构体 `Node`，表示链表中的一个结点。然后定义了链表的头指针 `head`，用来动态地建立链表。程序通过循环读入若干个正整数，每读入一个数就创建一个新的结点，并将其插入链表的头部，实现逆序建立链表。最后，程序遍历链表，输出链表的逆序。

注意，在程序最后，我们同样需要释放链表结点的内存，避免内存泄漏。这里采用了一个简单的方法，即遍历链表，逐个删除每个结点。需要注意的是，C语言中需要使用 `malloc()` 函数动态分配内存，使用 `free()` 函数释放内存。