输入一个整数n，再输入n个整数，按照输入的顺序建立单链表，并遍历所建立的单链表，输出这些数据。

### 回答1：
好的，以下是用中文回答您的问题：

您可以按照以下步骤建立单链表：

1. 输入一个整数 n，表示链表中元素的个数。
2. 输入 n 个整数，表示链表中每个节点的值。
3. 按照输入的顺序依次建立每个节点，并将它们按照顺序连接起来，形成单链表。

以下是具体的代码实现：

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None
        
def build_linked_list():
    n = int(input("请输入链表中元素的个数: "))
    head = None
    tail = None
    
    for i in range(n):
        val = int(input("请输入第 {} 个节点的值: ".format(i+1)))
        node = Node(val)
        
        if head is None:
            head = node
            tail = node
        else:
            tail.next = node
            tail = node
            
    return head

def print_linked_list(head):
    while head is not None:
        print(head.val, end=" ")
        head = head.next
        
head = build_linked_list()
print_linked_list(head)

在上面的代码中，我们首先定义了一个 `Node` 类来表示单链表的节点。该类有两个属性：`val` 表示节点的值，`next` 表示指向下一个节点的指针。

然后我们定义了两个函数，分别是 `build_linked_list()` 和 `print_linked_list()`。`build_linked_list()` 函数用来建立单链表，具体的实现方式是通过循环输入每个节点的值，然后按照输入的顺序建立每个节点，并将它们连接起来形成单链表。最后返回单链表的头节点。

`print_linked_list()` 函数用来遍历单链表并输出其中的每个节点的值，具体的实现方式是通过循环遍历单链表，依次输出每个节点的值。

最后，我们可以通过调用 `build_linked_list()` 函数建立一个单链表，然后再调用 `print_linked_list()` 函数遍历并输出单链表中的每个节点的值。

### 回答2：
单链表是一种线性数据结构，由多个节点按顺序组成，每个节点包含两个部分：数据域和指针域，其中数据域 存储节点的数据，指针域存储下一个节点的地址。在本题中，输入一个整数n，再输入n个整数，按照输入的顺序建立单链表，并遍历所建立的单链表，输出这些数据。

下面介绍单链表的建立方法和遍历方法：

1. 单链表的建立方法

（1）定义链表节点结构体

定义链表节点结构体，包含一个整型数据和一个下一节点的地址。

struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};

（2）输入n个整数并创建节点

输入n个整数，并创建对应的节点。

ListNode* head = new ListNode(0);
ListNode* p = head;
int num;
cin >> num;
while (num--) {
int x;
cin >> x;
ListNode* node = new ListNode(x);
p->next = node;
p = p->next;
}

（3）返回链表头节点

ListNode* res = head->next;
delete head;
return res;

2. 单链表的遍历方法

利用一个指针cur遍历链表，每次输出当前节点的值，并将cur指向下一个节点，直到结束。

void traverse(ListNode* head) {
ListNode* cur = head;
while (cur) {
cout << cur->val << " ";
cur = cur->next;
}
}

将以上两个函数结合起来，即可完成本题的要求：

int main() {
int n;
cin >> n;
ListNode* head = createList(n);
traverse(head);
return 0;
}

### 回答3：
单链表是一种常用的线性数据结构，可以用来存储一组有序的数据。单链表由多个节点组成，每个节点包含一个数据元素和一个指向下一节点的指针。

题目要求我们输入一个整数n，表示接下来将输入n个整数，并按照顺序建立单链表，然后遍历该单链表并输出所有数据。

建立单链表的过程可以通过循环实现，依次读取每个整数，创建一个新节点，并将该节点插入链表的末尾。具体实现如下：

1. 创建一个空的单链表，并用一个指针p指向它的表头。
2. 依次读取输入的n个整数，对于每个整数x，创建一个新节点，并将其插入链表的末尾。
1) 创建一个新节点newnode，设置其元素值为x，将其指针域设置为NULL。
2) 将p指向链表的表头。
3) 从表头沿着链表往后遍历，直到找到最后一个节点lastnode。
4) 将lastnode的指针域指向新节点newnode，将新节点的指针域设为NULL。
3. 遍历整个单链表，并输出每个节点的元素值。

代码如下：

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

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

struct ListNode* createList(int n)
{
struct ListNode *head = NULL, *p = NULL, *newnode = NULL;
int i, val;
for (i = 0; i < n; i++) {
scanf("%d", &val);
newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
newnode->val = val;
newnode->next = NULL;
if (head == NULL) {
head = newnode;
p = head;
}
else {
p->next = newnode;
p = newnode;
}
}
return head;
}

void printList(struct ListNode* head)
{
struct ListNode *p = head;
while (p != NULL) {
printf("%d ", p->val);
p = p->next;
}
printf("\n");
}

int main()
{
int n;
scanf("%d", &n);
struct ListNode *head = createList(n);
printList(head);
return 0;
}

在主函数中，我们首先读取输入的整数n，然后调用createList函数创建单链表。最后，调用printList函数遍历单链表并输出所有数据。