C语言单链表取 插入 删除

reateList L(LinkList &L, int n)
11建立单链表
GetElem(L, i, &e)//取第i个数据元素
ListInsert(&L.,i,e)//插入数据元素
ListDelete(&L, i, e)
∥删除数据元素

img

这个网上一搜一大把 整一个资源给你 https://www.iiice.cn/ChatGPT

引用 皆我百晓生 小程序回复内容作答：
单链表的基本操作包括创建链表、获取元素、插入元素和删除元素。

1.创建链表
在C语言中，可以使用结构体和指针来表示单链表。定义一个结构体来表示链表的节点，包含一个数据域和一个指向下一个节点的指针域。创建链表时，需要动态分配内存来存储节点。

typedef struct LNode{
    ElemType data; // 数据域
    struct LNode *next; // 指针域
}LNode, *LinkList;

LinkList CreateList(LinkList &L, int n){
    L = (LNode*)malloc(sizeof(LNode)); // 创建头节点
    L->next = NULL; // 头节点的指针域为空
    for(int i = n; i > 0; i--){
        LNode *p = (LNode*)malloc(sizeof(LNode));
        scanf("%d", &p->data); // 输入数据
        p->next = L->next; // 插入到头节点后
        L->next = p; // 头节点的指针指向新节点
    }
    return L;
}

2.获取元素
根据传入的索引i，找到链表的第i个节点并获取其中的数据。需要遍历链表，通过指针依次访问节点。

Status GetElem(LinkList L, int i, ElemType &e){
    LNode *p = L->next;
    int j = 1;
    while(p && j < i){
        p = p->next;
        j++;
    }
    if(!p || j > i){
        return ERROR;
    }
    e = p->data;
    return OK;
}

3.插入元素
根据传入的索引i，在链表的第i个节点之前插入新节点，并设置新节点的数据。需要先找到第i-1个节点，然后将新节点插入到该节点后。

Status ListInsert(LinkList &L, int i, ElemType e){
    LNode *p = L;
    int j = 0;
    while(p && j < i-1){
        p = p->next;
        j++;
    }
    if(!p || j > i-1){
        return ERROR;
    }
    LNode *q = (LNode*)malloc(sizeof(LNode));
    q->data = e;
    q->next = p->next;
    p->next = q;
    return OK;
}

4.删除元素
根据传入的索引i，在链表中删除第i个节点，并获取其数据。需要先找到第i-1个节点，然后将第i个节点删除，并释放其内存。

Status ListDelete(LinkList &L, int i, ElemType &e){
    LNode *p = L;
    int j = 0;
    while(p->next && j < i-1){
        p = p->next;
        j++;
    }
    if(!(p->next) || j > i-1){
        return ERROR;
    }
    LNode *q = p->next;
    p->next = q->next;
    e = q->data;
    free(q);
    return OK;
}

注意：在实际使用中，需要在程序结束时手动释放链表的内存，避免内存泄漏。可以通过一个循环，释放链表中每个节点的内存。

供参考：

#include <stdio.h>
#include <stdlib.h>
typedef int DataType;
typedef struct Lnode {
    DataType      data;
    struct Lnode* next;
}ListNode, Node, * LinkList;

void CreateList_L(LinkList& L, int n)
{
    DataType  i;
    LinkList  qt = NULL, pL = NULL;
    L = (LinkList)malloc(sizeof(ListNode));
    if (!L)  return;
    L->next = NULL;
    pL = L;
    for (i = 0; i < n; i++)
    {
        qt = (ListNode*)malloc(sizeof(ListNode));
        if (!qt)   break;
        qt->next = NULL;
        scanf("%d", &qt->data);
        pL->next = qt;
        pL = qt;
    }
}
void ListInsert(LinkList &L, int i, DataType e)
{
    ListNode* p = L, * s = NULL;
    if (i < 1 || !L)  return;
    while (p->next && i--)  p = p->next;
    if (i >= 1) return;
    s = (ListNode*)malloc(sizeof(ListNode));
    if (!s)  return;
    s->next = NULL;
    s->data = e;
    s->next = p->next;
    p->next = s;
}
void ListDelete(LinkList& L, int i, DataType& e)
{
    ListNode* p = L, * s = NULL;
    e = -1;
    if (i < 1 || !L || !L->next)
        return;
    while (p->next && --i)  p = p->next;
    if (!p->next)
        return;
    s = p->next;    
    p->next = s->next;
    e = s->data;
    free(s);
}
void GetElem(LinkList L, int i,DataType &e)
{
    Node* p = L;
    e = -1;
    if (i < 1 || !L || !L->next) return;
    while (p->next && --i)  p = p->next;
    if (!p->next)  return;
    e = p->next->data;
}
void PrintList(LinkList L)
{
    ListNode* p = NULL;
    if (!L || !L->next)
        printf("NULL");
    else {
        p = L->next;
        while (p != NULL)
        {
            printf(p == L->next ? "%d" : " %d", p->data);
            p = p->next;
        }
    }
    printf("\n");
}
int main()
{
    DataType n, i, e;
    LinkList L = NULL;

    scanf("%d", &n);    // 建立链表
    CreateList_L(L, n);
    PrintList(L);       // 输出链表

    i = 2; e = 100;     // 指定位置 i 插入结点，结点值 e = 100
    ListInsert(L, i, e);
    PrintList(L);       // 输出链表

    i = 1;               // 删除指定位置 i 的结点
    ListDelete(L, i, e);
    if (e != -1)
        printf("删除结点值为：%d\n", e);
    else
        printf("删除结点不存在!\n");

    i = 5;                // 取得指定位置 i 的结点值
    GetElem(L, i, e);
    if (e != -1)
        printf("第%d个结点值为：%d\n", i, e);
    else
        printf("第%d个结点不存在!\n", i);

    PrintList(L);
    return 0;
}

【以下回答由 GPT 生成】

解决方案

1. 创建一个单链表

首先，我们可以通过使用结构体来表示链表节点。结构体中包含两个部分：一个是用来存储实际数据的数据域，另一个是指向下一个节点的指针域。

// 定义链表节点结构体
typedef struct Node {
    int data;               // 数据域
    struct Node* next;      // 指针域，指向下一个节点
} Node;

// 创建链表函数
Node* createLinkedList() {
    Node *head = NULL;      // 链表头节点指针
    Node *tail = NULL;      // 链表尾节点指针

    // 循环读取数据，并创建新节点进行连接
    int data;
    while (scanf("%d", &data) != EOF) {
        // 创建新的节点
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = data;
        newNode->next = NULL;

        // 如果链表为空，将头节点指向新节点
        if (head == NULL) {
            head = newNode;
            tail = newNode;
        } else {
            // 否则，将尾节点的指针指向新节点
            tail->next = newNode;
            tail = newNode;
        }
    }

    return head;
}

2. 获取链表中第i个数据元素的值

为了获取链表中第i个数据元素的值，我们可以通过循环遍历链表，直到找到第i个节点。

int getLinkedListElement(Node* head, int i) {
    // 遍历链表
    Node* p = head;
    int count = 0;
    while (p != NULL) {
        // 如果找到第i个节点，返回节点的数据域值
        if (count == i) {
            return p->data;
        } else {
            p = p->next;
            count++;
        }
    }
    // 如果链表中没有第i个位置，返回一个特定的值，例如-1
    return -1;
}

3. 在链表中的第i个位置插入一个新的数据元素

要在链表中的第i个位置插入一个新的数据元素，我们需要创建一个新节点，并调整节点之间的连接关系。

void insertLinkedListElement(Node* head, int i, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;

    // 遍历链表，找到第i-1个节点
    Node* p = head;
    int count = 0;
    while (p != NULL && count < i - 1) {
        p = p->next;
        count++;
    }

    if (p != NULL) {
        // 将新节点的指针域指向第i个节点
        newNode->next = p->next;
        // 将第i-1个节点的指针域指向新节点
        p->next = newNode;
    } else {
        printf("插入位置超出链表长度");
    }
}

4. 删除链表中的第i个位置上的数据元素

删除链表中的第i个节点时，我们需要找到第i-1个节点，并调整节点之间的连接关系。

void deleteLinkedListElement(Node* head, int i) {
    // 遍历链表，找到第i-1个节点
    Node* p = head;
    int count = 0;
    while (p != NULL && count < i - 1) {
        p = p->next;
        count++;
    }

    if (p != NULL && p->next != NULL) {
        // 保存第i个节点
        Node* q = p->next;
        // 将第i-1个节点的指针域指向第i+1个节点
        p->next = q->next;
        // 释放第i个节点的内存空间
        free(q);
    } else {
        printf("删除位置超出链表长度");
    }
}

这样，我们就可以通过上述代码实现了使用C语言进行单链表的创建、插入和删除操作。

参考资料： 1. C语言单链表的创建、插入和删除



【相关推荐】



如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^