编写4个函数，功能分别为创建单链表，输出单链表，删除链表中的第i个结点，在第i个结点之前插入一个结点。在主程序中调用这些函数，并把运行结果截屏上传。 #include<stdio.h> #include<stdlib.h> typedef struct Lnode {int data; struct Lnode *next; }Lnode,*Linklist; Linklist create(int n)//创建一个含有n个结点的单链表 void print(Linklist L)//输出单链表L中的各个元素 void inserti(Linklist L,int i,int x) //在第i个结点之前插入一个数据域为x的结点 void deletei(Linklist L, int i)//删除链表中第i个结点 void main() {int n,i,x; Lnode *L; scanf("%d",&n); L=create(n); print(L); scanf("%d",&i); deletei(L,i); print(L); scanf("%d %d",&i,&x); inserti(L,i,x); print(L); }

创建单链表函数：该函数用于创建一个单链表，输入参数为链表的长度，返回值为链表的头结点。

输出单链表函数：该函数用于输出单链表的所有结点的值，输入参数为链表的头结点，无返回值。

删除链表中的第i个结点函数：该函数用于删除单链表中的第i个结点，输入参数为链表的头结点和要删除的结点的位置i，无返回值。

在第i个结点之前插入一个结点函数：该函数用于在单链表中第i个结点之前插入一个新的结点，输入参数为链表的头结点、要插入的结点的位置i和要插入的结点的值，无返回值。

主程序中调用这些函数，并把运行结果截屏上传。

相关问题

编写3个函数，分别实现单链表（带头结点）的查询、插入、删除。 函数接口定义：

以下是基本的单链表（带头结点）结构体定义：

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

其中，`data`表示节点存储的数据，`next`表示该节点的后继节点指针。`LinkedList`是头结点指针。

接下来是3个函数的实现：

1. 查询函数：

Node* find(LinkedList list, int x) {
    Node* p = list->next; // 指向第一个节点
    while(p != NULL && p->data != x) {
        p = p->next;
    }
    return p;
}

查询函数的功能是在链表中查找值为`x`的节点，若找到则返回该节点的指针，否则返回`NULL`。

2. 插入函数：

bool insert(LinkedList list, int pos, int x) {
    Node* p = list;
    for(int i = 0; i < pos - 1 && p != NULL; i++) {
        p = p->next;
    }
    if(p == NULL) {
        return false; // 插入位置无效
    }
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = x;
    newNode->next = p->next;
    p->next = newNode;
    return true;
}

插入函数的功能是在链表的第`pos`个位置插入值为`x`的节点，若插入成功则返回`true`，否则返回`false`。

3. 删除函数：

bool del(LinkedList list, int x) {
    Node* p = list;
    while(p->next != NULL && p->next->data != x) {
        p = p->next;
    }
    if(p->next == NULL) {
        return false; // 要删除的节点不存在
    }
    Node* q = p->next;
    p->next = q->next;
    free(q); // 释放空间
    return true;
}

删除函数的功能是删除链表中值为`x`的节点，若删除成功则返回`true`，否则返回`false`。

编写3个函数，分别实现单链表（带头结点）的查询、插入、删除。

### 回答1：
函数1：单链表查询

函数名：searchLinkedList

参数：头结点指针head，待查询元素值value

返回值：若找到返回该元素在链表中的位置，否则返回

函数实现：

int searchLinkedList(Node *head, int value) {
Node *p = head->next;
int pos = 1;
while (p != NULL) {
if (p->data == value) {
return pos;
}
p = p->next;
pos++;
}
return ;
}

函数2：单链表插入

函数名：insertLinkedList

参数：头结点指针head，待插入元素值value，插入位置pos

返回值：若插入成功返回1，否则返回

函数实现：

int insertLinkedList(Node *head, int value, int pos) {
Node *p = head;
int i = ;
while (p != NULL && i < pos - 1) {
p = p->next;
i++;
}
if (p == NULL || i > pos - 1) {
return ;
}
Node *newNode = (Node *)malloc(sizeof(Node));
newNode->data = value;
newNode->next = p->next;
p->next = newNode;
return 1;
}

函数3：单链表删除

函数名：deleteLinkedList

参数：头结点指针head，待删除元素值value

返回值：若删除成功返回1，否则返回

函数实现：

int deleteLinkedList(Node *head, int value) {
Node *p = head->next;
Node *pre = head;
while (p != NULL) {
if (p->data == value) {
pre->next = p->next;
free(p);
return 1;
}
pre = p;
p = p->next;
}
return ;
}

### 回答2：
单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。在单链表的操作中，常用的有查询、插入和删除。下面将介绍三个函数分别实现单链表的查询、插入、删除。

1. 查询函数

查询函数的作用是查找目标元素在单链表中是否存在。它的参数是一个链表头指针和一个待查找的元素值。查询函数通过遍历单链表，如果找到指定元素，返回该节点的指针；如果未找到，返回 NULL。

代码实现：

Node* search(Node* head, int value) {
    Node* p = head->next; // 从头结点的下一个节点开始查找
    while (p != NULL) {
        if (p->data == value) {
            return p; // 返回找到的节点
        }
        p = p->next; // 指针后移
    }
    return NULL; // 未找到，则返回 NULL
}

2. 插入函数

插入函数的作用是在单链表中添加一个新节点。它的参数是一个链表头指针、待插入的位置和待插入的元素值。插入函数先判断待插入位置是否合法，然后创建新节点，将其插入到对应位置。

代码实现：

bool insert(Node* head, int pos, int value) {
    Node* p = head; // 从头结点开始查找插入位置
    for (int i = 0; i < pos && p != NULL; i++) {
        p = p->next; // 指针后移
    }
    if (p == NULL) {
        return false; // 插入位置非法，返回失败
    }
    Node* q = new Node(); // 创建新节点
    q->data = value;
    q->next = p->next; // 新节点插入到链表中
    p->next = q;
    return true; // 插入成功
}

3. 删除函数

删除函数的作用是删除单链表中的某个节点。它的参数是一个链表头指针和待删除的元素值。删除函数先遍历单链表，找到待删除节点的前一个节点，然后将待删除节点从链表中删除。

代码实现：

bool remove(Node* head, int value) {
    Node* p = head; // 从头结点开始查找待删除节点
    while (p->next != NULL && p->next->data != value) {
        p = p->next; // 指针后移
    }
    if (p->next == NULL) {
        return false; // 链表中无待删除节点，返回失败
    }
    Node* q = p->next; // 待删除节点
    p->next = q->next; // 将待删除节点从链表中删除
    delete q; // 释放待删除节点的空间
    return true; // 删除成功
}

综上所述，单链表的查询、插入、删除函数分别实现了单链表的查询、插入、删除操作。它们可以应用在许多实际场景中，如链表排序和链表操作。

### 回答3：
单链表是一种常见的数据结构，它由多个节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。单链表可以快速插入和删除元素，但查找需要遍历整个链表。下面将介绍如何用三个函数实现单链表的查询、插入和删除。

1. 实现查询操作

单链表的查询操作需要遍历整个链表，直到找到目标元素或到达链表结尾。代码如下：

def search_linked_list(head, target):
    curr = head.next
    while curr != None:
        if curr.data == target:
            return True
        curr = curr.next
    return False

其中，head是单链表的头结点，target是要查找的目标元素。curr表示当前遍历到的节点，初始时指向第一个节点（即头结点的下一个节点）。如果当前节点的元素等于目标元素，则返回True；否则继续遍历下一个节点。如果遍历到链表结尾仍未找到目标元素，则返回False。

2. 实现插入操作

单链表的插入操作需要在指定位置插入新的节点。具体步骤如下：

- 创建新节点，并将其next指针指向插入位置的下一个节点；
- 将插入位置的前一个节点的next指针指向新节点。

代码如下：

def insert_linked_list(head, pos, data):
    curr = head
    for i in range(pos):
        curr = curr.next
    new_node = Node(data)
    new_node.next = curr.next
    curr.next = new_node

其中，pos表示插入位置，data表示要插入的数据元素。curr表示当前遍历到的节点，初始时指向头结点。for循环遍历链表，找到插入位置的前一个节点。创建新节点，并将其next指针指向插入位置的下一个节点。将插入位置的前一个节点的next指针指向新节点即可完成插入操作。

3. 实现删除操作

单链表的删除操作需要找到要删除的节点，并将其前一个节点的next指针指向删除节点的下一个节点。代码如下：

def delete_linked_list(head, target):
    curr = head
    while curr.next != None:
        if curr.next.data == target:
            curr.next = curr.next.next
            return
        curr = curr.next

其中，target表示要删除的目标元素。curr表示当前遍历到的节点，初始时指向头结点。while循环遍历链表，判断当前节点的下一个节点是否为要删除的目标节点。如果是，则将当前节点的next指针指向目标节点的下一个节点，即完成删除操作。

综上，通过以上三个函数可以实现单链表的查询、插入和删除操作。需要注意的是，需要先定义节点类Node，并在head节点的初始化中创建一个空节点。