实现含头结点的单链表 属性包括：data数据域、next指针域 操作包括：创建、显示 注意：单链表不是数组，所以位置从1开始对应首结点，头结点不放数据 输入 第1行先输入n表示有n个数据，接着输入n个数据 输出 数据之间用空格隔开， 第1行输出创建后的单链表的数据

### 回答1：
以下是含头结点的单链表的完整代码，包括创建和显示操作：

-- 定义链表节点结构体
local ListNode = {}
ListNode.__index = ListNode
function ListNode.new(data)
  local obj = {}
  obj.data = data
  obj.next = nil
  setmetatable(obj, ListNode)
  return obj
end

-- 定义单链表结构体
local LinkedList = {}
LinkedList.__index = LinkedList
function LinkedList.new()
  local obj = {}
  obj.head = ListNode.new(nil)
  setmetatable(obj, LinkedList)
  return obj
end

-- 创建单链表
function LinkedList:create(nums)
  local curr = self.head
  for i = 1, #nums do
    local node = ListNode.new(nums[i])
    curr.next = node
    curr = node
  end
end

-- 显示单链表
function LinkedList:display()
  local curr = self.head.next
  while curr do
    io.write(curr.data .. " ")
    curr = curr.next
  end
  io.write("\n")
end

-- 测试代码
local n = tonumber(io.read())
local nums = {}
for i = 1, n do
  nums[i] = tonumber(io.read())
end

local ll = LinkedList.new()
ll:create(nums)
ll:display()

输入样例：

5
1 2 3 4 5

输出样例：

1 2 3 4 5 

### 回答2：
实现含头结点的单链表，可以使用结构体来定义节点的属性和操作。

首先，定义一个结构体Node，包含两个属性：data和next。其中，data表示数据域，用来存储节点的数据；next表示指针域，用来指向下一个节点。

然后，定义一个函数createList，用来创建一个含头结点的单链表。输入参数为一个整数n，表示要创建的节点个数。函数内部通过循环读取n个数据，并创建对应的节点，将节点连接成链表。

接下来，定义一个函数displayList，用来显示链表中的数据。函数内部通过循环遍历链表的每个节点，依次输出其data属性的值，数据之间用空格隔开。

最后，在主函数中，首先读取输入的n，然后调用createList函数创建链表，并调用displayList函数显示链表中的数据。

具体代码如下：

#include <iostream>
using namespace std;

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

Node* createList(int n) {
    Node* head = new Node;  // 创建头结点
    head->next = nullptr;  // 头结点的指针域为空

    Node* p = head;
    for (int i = 0; i < n; i++) {
        int num;
        cin >> num;

        Node* newNode = new Node;  // 创建新节点
        newNode->data = num;       // 将输入的数据存储到新节点的数据域中
        newNode->next = nullptr;   // 新节点的指针域为空

        p->next = newNode;         // 将新节点连接到链表尾部
        p = newNode;               // 更新p指针为新节点
    }

    return head;
}

void displayList(Node* head) {
    Node* p = head->next;

    while (p != nullptr) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

int main() {
    int n;
    cin >> n;

    Node* head = createList(n);
    displayList(head);

    return 0;
}

这样，只需输入一个整数n表示有n个数据，接着输入n个数据，即可输出创建后的单链表的数据。

### 回答3：
单链表是一种常用的数据结构，其中每一个节点都包含一份数据与一个指向下一个节点的指针。在实现含头结点的单链表时，头结点通常不放置数据，用来简化操作。

创建单链表的过程如下：
1. 在头结点之后创建第一个节点，将输入的第一个数据存入该节点的数据域。
2. 从第二个节点开始，依次创建节点，将输入的数据存入各个节点的数据域。
3. 将每个节点的指针域指向下一个节点，直到最后一个节点的指针域指向NULL。

显示单链表的数据的操作如下：
1. 从头结点的下一个节点开始遍历链表，依次输出每个节点的数据域。
2. 在输出过程中，每个数据后面添加一个空格来进行分隔。

下面是根据以上要求实现的示例代码：

class Node:
    def __init__(self, data=None):
        self.data = data
        self.next = None

def create_linked_list(n):
    head = Node() # 创建头结点
    cur = head # cur指针指向当前节点
    for _ in range(n):
        data = int(input())
        new_node = Node(data) # 创建新节点
        cur.next = new_node # 当前节点的指针域指向新节点
        cur = new_node # cur指向新节点
    return head

def display_linked_list(head):
    cur = head.next # cur指针指向第一个节点
    while cur:
        print(cur.data, end=' ')
        cur = cur.next

n = int(input())
linked_list = create_linked_list(n)
display_linked_list(linked_list)

以上代码实现了根据输入创建含头结点的单链表，并最后输出所创建的单链表的数据。