单链表的创建与读取，插入与删除

求帮忙看一下哪里错了
不会把代码搞过来只能用图片 本人在自学数据结构水平有限 恳请指正

是编译报错吗？还是运行到那个功能时有问题呢？
main函数里有问题啊，L不要指向x，x变量删掉，后面用x的地方都改用L
因为create函数中，重新给L指针分配了空间，所以你链表和x是没有关系的。后面对x的使用就没有用了

该回答引用GPTᴼᴾᴱᴺᴬᴵ
你的代码有一些语法错误和逻辑错误，下面我给你修正一下。

#include<iostream>
using namespace std;

#define ERROR 0
#define OK 1

typedef int ElemType;
typedef int Status;

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;

typedef struct Node *LinkList;

// 尾插法创建链表，新节点插在终端结点的后面，头结点为空
void CreateListTail(LinkList *L, int n)
{
    LinkList p, r;
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;
    for (int i = 0; i < n; i++)
    {
        p = (Node*)malloc(sizeof(Node));
        p->data = i;
        r->next = p;
        r = p;
    }
    r->next = NULL; // 单链表的结束
}

// 链表的读取，获取链表中第i个元素的值
Status GetElem(LinkList L, int i, ElemType *e)
{
    int j = 1; // 链表下标从1开始
    LinkList p = L->next;
    while (p && j < i)
    {
        p = p->next;
        j++;
    }
    if (!p || j > i)
        return ERROR;
    *e = p->data;
    return OK;
}

// 单链表的插入，在L的第i个元素之前插入元素e
Status ListInsert(LinkList *L, int i, ElemType e)
{
    int j = 1;
    LinkList p = *L, s;
    while (p && j < i)
    {
        p = p->next;
        j++;
    }
    if (!p || j > i)
        return ERROR;
    s = (LinkList)malloc(sizeof(Node));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return OK;
}

// 单链表的删除，删除L中第i个元素并用e返回其值
Status ListDelete(LinkList *L, int i, ElemType *e)
{
    int j = 1;
    LinkList p = *L, q;
    while (p->next && j < i)
    {
        p = p->next;
        j++;
    }
    if (!(p->next) || j > i)
        return ERROR;
    q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    return OK;
}

int main()
{
    LinkList x;
    LinkList *L = &x;
    int n;
    cin >> n;
    ElemType a, b, c;
    cin >> b;
    ElemType *e = &a;
    ElemType *d = &c;
    CreateListTail(L, n);
    GetElem(x, 3, e);
    ListInsert(L, 5, b);
    ListDelete(L, 4, d);
    for (int i = 0; i < n; i++)
    {
        cout << x->data << " ";
        x = x->next;
    }
    return 0;
}

修改后的代码已经可以正常运行了。注意，你在输出链表元素的时候，应该使用`cout << x->data << " ";

参考GPT和自己的思路，以下是修改后的代码：

#include<iostream>
using namespace std;

#define ERROR 0
#define OK 1

typedef int ElemType;
typedef int Status;
typedef struct Node {
    ElemType data;
    struct Node* next;
} Node;
typedef struct Node* LinkList;

//尾插法创建链表，新节点插在终端结点的后面头结点为空
void CreateListTail(LinkList* L, int n) {
    LinkList p, r;
    int i;
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;
    for (i = 0; i < n; i++) {
        p = (Node*)malloc(sizeof(Node));
        p->data = i;
        r->next = p;
        r = p;
    }
    r->next = NULL;
}

//单链表的读取
Status GetElem(LinkList L, int i, ElemType* e) {
    int j;
    LinkList p;
    p = L->next;
    j = 1;//链表下标从1开始
    while (p && j < i) {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
        return ERROR;
    *e = p->data;
    return OK;
}

//单链表的插入在L的第i个元素之前插入元素e
Status ListInsert(LinkList* L, int i, ElemType e) {
    int j;
    LinkList p, s;
    p = *L;
    j = 1;
    while (p && j < i) {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
        return ERROR;
    s = (LinkList)malloc(sizeof(Node));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return OK;
}

//单链表的删除删除L中第i个元素并用e返回其值
Status ListDelete(LinkList* L, int i, ElemType* e) {
    int j;
    LinkList p, q;
    p = *L;
    j = 1;
    while (p->next && j < i) {
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i)
        return ERROR;
    q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    return OK;
}

int main() {
    LinkList x;
    LinkList* L = &x;
    int n;
    cin >> n;
    ElemType a, b, c;
    cin >> b;
    ElemType* e = &a;
    ElemType* d = &c;
    CreateListTail(L, n);
    GetElem(x, 3, e);
    ListInsert(L, 5, b);
    ListDelete(L, 4, d);
    for (int i = 0; i < n; i++) {
        cout << x->data << " ";
        x = x->next;
    }
    return 0;
}

回答不易，还请采纳！！！

• 这个问题的回答你可以参考下: https://ask.csdn.net/questions/7784961
• 这篇博客你也可以参考下：单链表的创建、插入、删除

以下答案由GPT-3.5大模型与博主波罗歌共同编写：
好的，我会详细解答你关于单链表的创建、读取、插入和删除的问题。 我先给出代码，然后逐步解释每一步的含义。

单链表的创建和读取：

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

class LinkedList:
    def __init__(self):
        self.head = None
    
    def insert(self,data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
            return
        cur_node = self.head
        while cur_node.next is not None:
            cur_node = cur_node.next
        cur_node.next = new_node  
    
    def display(self):
        if self.head is None:
            return
        current_node = self.head
        while current_node is not None:
            print(current_node.data,end = ' ')
            current_node = current_node.next

在上面的代码中，我们定义了两个类，一个是节点类(Node)，一个是单链表类(LinkedList)。

我们首先要定义节点类，每个节点包含两个属性，分别是data和next，其中data表示节点存储的数据，next表示指向下一个节点的指针。

在单链表类中，我们首先定义一个头节点(head)，表示单链表的开头。 然后我们定义了一个插入操作(insert)，该操作接受一个数据参数，并将该数据插入到单链表的末尾。

在插入操作(insert)中，我们首先要创建一个新节点(new_node)，存储要插入的数据。 然后我们检查头节点是否为空，如果为空，则将新节点设置为头节点。否则，我们需要遍历单链表，找到最后一个节点，并将新节点链接到该节点的next上。

最后，我们定义了一个显示操作(display)，该操作用于遍历单链表，并将每个节点的数据从头到尾输出。

单链表的插入：

现在，我们来看看如何实现在单链表的任意位置插入一个节点。

    def insert_node(self,data,index):
        new_node = Node(data)
        if index == 0:
            new_node.next = self.head
            self.head = new_node
            return
        cur_node = self.head
        cur_index = 0
        while cur_index < index-1:
            cur_node = cur_node.next
            cur_index += 1
            if cur_node is None:
                return
        new_node.next = cur_node.next
        cur_node.next = new_node

在上面的代码中，我们定义了一个新的插入节点方法(insert_node)，该方法接受两个参数，分别是要插入的数据和要插入的位置。

首先，我们创建一个新的节点(new_node)，表示要插入的数据。然后我们检查要插入的位置是否为0，如果是，则我们需要将新节点插入到单链表的头部。

否则，我们使用一个游标指针(cur_node)指向链表的头部。然后我们在循环中遍历单链表，直到我们找到要插入位置的前一个节点。 在这之后，我们将新节点插入到链表中，并将新节点的next指向前一个节点的next。最后，我们将前一个节点的next指向新节点，这样就完成了在单链表中插入新节点的操作。

单链表的删除：

现在，我们来看看如何实现在单链表中删除一个节点。

    def delete_node(self,index):
        if self.head is None:
            return
        cur_node = self.head
        if index == 0:
            self.head = cur_node.next
            cur_node = None
            return
        prev_node = None
        cur_index = 0
        while cur_index < index and cur_node:
            prev_node = cur_node
            cur_node = cur_node.next
            cur_index += 1
        if cur_node is None:
            return
        prev_node.next = cur_node.next
        cur_node = None

在上面的代码中，我们定义了一个新的删除节点方法(delete_node)，该方法接受一个参数，即要删除的节点的位置。

首先，我们需要检查头节点是否为空。如果是，我们就直接返回。接下来，我们使用一个游标指针(cur_node)指向头节点，并检查要删除的位置是否为0。如果是，我们需要将头节点替换为cur_node的next，并将cur_node置为空。这就完成了在单链表的头部删除一个节点的操作。

否则，我们使用两个游标(prev_node和cur_node)分别指向cur_node的前一个节点和当前节点。 然后我们遍历单链表，直到我们找到要删除的节点位置。在这之后，我们将prev_node的next指向cur_node的next，并将cur_node置为空。这样，我们就完成了在单链表的任意位置删除一个节点的操作。

希望这可以帮到你，如果有任何问题，请随时问我。
如果我的回答解决了您的问题，请采纳！