编写一个函数creat，用来动态创建一个包含n个节点的单向链表、编写函数show来输出链表节点数据。每个节点存储一个整型数据。在主函数中创建一个长度为4的链表，并依次输出链表个节点的数据。

以下是Python代码实现：

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

def creat(n):
    head = Node()
    cur = head
    for i in range(1, n+1):
        new_node = Node(i)
        cur.next = new_node
        cur = cur.next
    return head.next

def show(head):
    cur = head
    while cur:
        print(cur.data)
        cur = cur.next

if __name__ == '__main__':
    head = creat(4)
    show(head)

函数creat接收一个整数n作为参数，返回一个包含n个节点的单向链表。函数show接收一个链表头节点作为参数，输出链表节点的数据。在主函数中，创建一个长度为4的链表，并依次输出链表节点的数据。

相关问题

编写一个函数creat，用来建立一个动态链表。编写一个print函数，将链表中各结点的数据依次输出。编写一个del函数，用来删除动态链表中的一个指定的结点。编写一个函数insert，用来向动态链表中插入一个结点。最后将四个函数组成一个系统，由主函数先后调用这些函数，实现链表的建立输出删除插入，再主程序中指定需要删除和插入的结点。

好的，我能够为您提供关于建立、输出、删除和插入动态链表的函数。以下是相应的代码示例：

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

class LinkedList:
    def __init__(self):
        self.head = None

    def create_list(self, data):
        new_node = Node(data)
        self.head = new_node
        
    def insert_at_beginning(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node

    def insert_at_end(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        curr = self.head
        while curr.next:
            curr = curr.next
        curr.next = new_node
    
    def insert_at_pos(self, data, pos):
        new_node = Node(data)
        if pos == 0:
            self.insert_at_beginning(data)
        else:
            curr, count = self.head, 0
            while curr and count != pos-1:
                curr = curr.next
                count += 1
            if not curr:
                print("Position out of bounds")
                return
            new_node.next = curr.next
            curr.next = new_node
    
    def delete_at_pos(self, pos):
        if not self.head:
            print("Linked List is empty")
            return
        if pos == 0:
            self.head = self.head.next
            return
        curr, count = self.head, 0
        while curr and count != pos-1:
            curr = curr.next
            count += 1
        if not curr or not curr.next:
            print("Position out of bounds")
            return
        curr.next = curr.next.next
    
    def print_list(self):
        curr = self.head
        while curr:
            print(curr.data)
            curr = curr.next

# Main program
my_list = LinkedList()
my_list.create_list(1)
my_list.insert_at_beginning(2)
my_list.insert_at_end(3)
my_list.insert_at_pos(4, 2)
my_list.delete_at_pos(1)
my_list.print_list()

这个例子展示了如何创建、输出、删除和插入数据到动态链表中。在这个例子中，我们定义了一个`Node`类，表示链表中的节点。然后，我们定义了`LinkedList`类，表示动态链表，并在该类中定义了用于创建、输出、删除和插入节点的方法。在主程序中，我们首先创建一个名为`my_list`的`LinkedList`对象，然后按顺序执行`create_list`、`insert_at_beginning`、`insert_at_end`、`insert_at_pos`和`delete_at_pos`等方法，最后输出整个链表。

希望这个例子能够对您有所帮助。如果您有任何其他问题，请随时问我。

要求你编写一个函数creat，用来建立一个动态链表

好的，我可以为您编写一个函数creat，该函数用于建立一个动态链表。

以下是该函数的示例代码：

#include <iostream>
using namespace std;

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

Node* creat(){
    Node* head = new Node();
    Node* p = head;
    int n;
    cout << "请输入链表的长度：";
    cin >> n;
    cout << "请输入链表的数据：" << endl;
    for(int i = 1; i <= n; ++i){
        Node* node = new Node();
        cin >> node->data;
        node->next = NULL;
        p->next = node;
        p = node;
    }
    return head->next;
}

int main(){
    Node* head = creat();
    while(head){
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
    return 0;
}

该函数首先创建一个头结点，并用指针p指向它。然后读入链表的长度n和n个数据，用指针node动态创建一个新结点，将数据存储到结点中，并将其插入到链表中。最后返回头结点的next域，即为整个链表。

希望这个函数能够满足您的需求。