操作系统——使用C语言实现单链表的创建、插入、删除，要求代表最简

已于 2023-04-01 14:45:09 修改
阅读量1.9k 收藏 21
点赞数 4
分类专栏： 初学者 虚拟机 C语言 文章标签： 链表 数据结构 ubuntu
于 2023-04-01 14:03:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45092728/article/details/129896578
版权
初学者 同时被 3 个专栏收录
12 篇文章 0 订阅
订阅专栏
虚拟机
2 篇文章 0 订阅
订阅专栏
C语言
1 篇文章 0 订阅
订阅专栏
该代码示例展示了如何使用C语言创建单链表，并实现按指针删除的插入、删除操作，包括在头部和尾部插入、删除节点。主要函数有create_list、insert_node、delete_node、insert_head、delete_head、insert_tail和delete_tail。
摘要由CSDN通过智能技术生成

Q:单链表是一种常见的数据结构，用于存储一系列具有相同类型的数据。在 C 语言中，可以通过定义一个结构体来表示链表的节点，并通过指针来链接各个节点。

以下是最简单的单链表的定义：

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

其中，data 表示节点存储的数据，next 表示指向下一个节点的指针。

接下来，我们可以实现单链表的创建、插入和删除操作：

创建一个空链表：

struct Node *head = NULL;

在链表末尾插入一个节点：


struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
new_node->data = value;
new_node->next = NULL;

if (head == NULL) {
    head = new_node;
} else {
    struct Node *cur = head;
    while (cur->next != NULL) {
        cur = cur->next;
    }
    cur->next = new_node;
}

其中，value 表示要插入的节点的数据。

在链表中删除一个节点：

if (head == NULL) {
    return;
}

if (head->data == value) {
    struct Node *tmp = head;
    head = head->next;
    free(tmp);
} else {
    struct Node *cur = head;
    while (cur->next != NULL && cur->next->data != value) {
        cur = cur->next;
    }
    if (cur->next == NULL) {
        return;
    }
    struct Node *tmp = cur->next;
    cur->next = cur->next->next;
    free(tmp);
}

其中，value 表示要删除的节点的数据。

这些操作可以组合起来，实现更复杂的功能。例如，可以编写一个函数来打印链表的所有节点：

void print_list(struct Node *head) {
    struct Node *cur = head;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
}

这是一个基本的单链表实现，但它并不是最优化的。在实际开发中，需要根据具体需求和数据规模选择最合适的数据结构和算法。

Q：在unbantu中，使用C语言实现单链表的创建、插入、删除，要求代码最简
以下是使用 C 语言实现单链表的最简代码：

#include <stdio.h>
#include <stdlib.h>

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

// 创建一个空链表
struct Node *head = NULL;

// 在链表末尾插入一个节点
void insert_node(int value) {
    struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
    new_node->data = value;
    new_node->next = NULL;

    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
}

// 在链表中删除一个节点
void delete_node(int value) {
    if (head == NULL) {
        return;
    }

    if (head->data == value) {
        struct Node *tmp = head;
        head = head->next;
        free(tmp);
    } else {
        struct Node *cur = head;
        while (cur->next != NULL && cur->next->data != value) {
            cur = cur->next;
        }
        if (cur->next == NULL) {
            return;
        }
        struct Node *tmp = cur->next;
        cur->next = cur->next->next;
        free(tmp);
    }
}

int main() {
    insert_node(1);
    insert_node(2);
    insert_node(3);
    delete_node(2);
    insert_node(4);

    struct Node *cur = head;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");

    return 0;
}

这段代码实现了单链表的创建、插入和删除操作，以及打印链表中所有节点的功能。代码相对简单，但仍保持了基本的可读性和可维护性。注意，在使用 malloc 分配内存时，需要对返回值进行检查以确保内存分配成功。

Q:在unbantu中，使用C语言实现单链表的创建、插入、删除三个代码，要求删除的时候按照指针删除

以下是使用 C 语言实现单链表的创建、插入、删除（按指针删除）的代码：


#include <stdio.h>
#include <stdlib.h>

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

// 创建一个空链表
struct Node *head = NULL;

// 在链表末尾插入一个节点
void insert_node(int value) {
    struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
    new_node->data = value;
    new_node->next = NULL;

    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
}

// 在链表中删除一个节点
void delete_node(struct Node **head_ref, int value) {
    struct Node *cur = *head_ref;
    struct Node *prev = NULL;

    while (cur != NULL && cur->data != value) {
        prev = cur;
        cur = cur->next;
    }

    if (cur == NULL) {
        return;
    }

    if (prev == NULL) {
        *head_ref = cur->next;
    } else {
        prev->next = cur->next;
    }

    free(cur);
}

int main() {
    insert_node(1);
    insert_node(2);
    insert_node(3);
    delete_node(&head, 2);
    insert_node(4);

    struct Node *cur = head;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");

    return 0;
}

这段代码实现了单链表的创建、插入和删除操作（按指针删除），以及打印链表中所有节点的功能。在删除节点时，需要使用指向指针的指针来传递头节点的地址，以便在删除节点时更新头节点。代码相对简单，但仍保持了基本的可读性和可维护性。注意，在使用 malloc 分配内存时，需要对返回值进行检查以确保内存分配成功。

Q:在unbantu中，使用C语言实现单链表的创建、插入、删除三个代码，要求删除的时候按照指针删除，创建单链表后插入所的值后再链表末尾插入一个结点
以下是使用 C 语言实现单链表的创建、插入、删除（按指针删除）的代码，以及创建单链表后插入所有的值并在链表末尾插入一个节点的功能：


#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node *next;
};
// 创建一个空链表
struct Node *head = NULL;
// 在链表末尾插入一个节点
void insert_node(int value) {
    struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
    new_node->data = value;
    new_node->next = NULL;
    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
}
// 在链表中删除一个节点
void delete_node(struct Node **head_ref, int value) {
    struct Node *cur = *head_ref;
    struct Node *prev = NULL;
    while (cur != NULL && cur->data != value) {
        prev = cur;
        cur = cur->next;
    }
    if (cur == NULL) {
        return;
    }
    if (prev == NULL) {
        *head_ref = cur->next;
    } else {
        prev->next = cur->next;
    }
    free(cur);
}
int main() {
    int values[] = {1, 2, 3};
    int n = sizeof(values) / sizeof(int);
    // 插入所有值
    for (int i = 0; i < n; i++) {
        insert_node(values[i]);
    }
    // 插入一个新的节点
    insert_node(4);
    // 删除一个节点
    delete_node(&head, 2);
    // 打印链表中所有节点的值
    struct Node *cur = head;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
    return 0;
}

这段代码实现了单链表的创建、插入和删除操作（按指针删除），以及创建单链表后插入所有的值并在链表末尾插入一个节点的功能。在删除节点时，需要使用指向指针的指针来传递头节点的地址，以便在删除节点时更新头节点。代码相对简单，但仍保持了基本的可读性和可维护性。注意，在使用 malloc 分配内存时，需要对返回值进行检查以确保内存分配成功。

Q:在unbantu中，使用C语言实现单链表的创建、插入、删除三个代码，要求删除的时候按照指针删除，创建单链表后插入节点和创建节点分开实现。
以下是使用 C 语言实现单链表的创建、插入、删除（按指针删除）的代码，分开实现节点创建和链表创建：


#include <stdio.h>
#include <stdlib.h>

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

// 创建一个空链表
struct Node *create_list() {
    return NULL;
}

// 在链表末尾插入一个节点
struct Node *insert_node(struct Node *head, struct Node *new_node) {
    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
    return head;
}

// 在链表中删除一个节点
struct Node *delete_node(struct Node *head, int value) {
    struct Node *cur = head;
    struct Node *prev = NULL;

    while (cur != NULL && cur->data != value) {
        prev = cur;
        cur = cur->next;
    }

    if (cur == NULL) {
        return head;
    }

    if (prev == NULL) {
        head = cur->next;
    } else {
        prev->next = cur->next;
    }

    free(cur);
    return head;
}

// 创建一个新节点
struct Node *create_node(int value) {
    struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
    new_node->data = value;
    new_node->next = NULL;
    return new_node;
}

int main() {
    // 创建一个空链表
    struct Node *head = create_list();

    // 创建所有的节点
    struct Node *node1 = create_node(1);
    struct Node *node2 = create_node(2);
    struct Node *node3 = create_node(3);
    struct Node *node4 = create_node(4);

    // 插入所有节点
    head = insert_node(head, node1);
    head = insert_node(head, node2);
    head = insert_node(head, node3);

    // 在链表末尾插入一个新节点
    head = insert_node(head, node4);

    // 删除一个节点
    head = delete_node(head, 2);

    // 打印链表中所有节点的值
    struct Node *cur = head;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");

    return 0;
}

这段代码实现了单链表的创建、插入和删除操作（按指针删除），并将节点创建和链表创建分开实现。在创建和插入节点时，我们使用了不同的函数来分离不同的功能。这样可以让代码更加清晰和易于维护。在删除节点时，我们需要返回新的头节点，因此需要更新函数的返回值。代码的逻辑相对简单，但仍保持了基本的可读性和可维护性。

Q:在unbantu中，使用C语言实现单链表的创建、插入、删除三个代码，要求删除的时候按照指针删除，创建单链表后插入节点和创建节点分开实现，实现单独插入一个结点，单独删除一个节点，在头部添加一个结点，在头部删除一个结点，在尾部添加一个节点，在尾部删除一个节点。

以下是使用 C 语言实现单链表的创建、插入、删除（按指针删除）的代码，分开实现节点创建和链表创建，并实现了插入和删除不同位置节点的功能：

#include <stdio.h>
#include <stdlib.h>

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

// 创建一个空链表
struct Node *create_list() {
    return NULL;
}

// 在链表末尾插入一个节点
struct Node *insert_node(struct Node *head, struct Node *new_node) {
    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
    return head;
}

// 在链表中删除一个节点
struct Node *delete_node(struct Node *head, int value) {
    struct Node *cur = head;
    struct Node *prev = NULL;

    while (cur != NULL && cur->data != value) {
        prev = cur;
        cur = cur->next;
    }

    if (cur == NULL) {
        return head;
    }

    if (prev == NULL) {
        head = cur->next;
    } else {
        prev->next = cur->next;
    }

    free(cur);
    return head;
}

// 在链表头部插入一个节点
struct Node *insert_head(struct Node *head, struct Node *new_node) {
    new_node->next = head;
    head = new_node;
    return head;
}

// 在链表头部删除一个节点
struct Node *delete_head(struct Node *head) {
    if (head == NULL) {
        return head;
    }
    struct Node *cur = head;
    head = head->next;
    free(cur);
    return head;
}

// 在链表尾部插入一个节点
struct Node *insert_tail(struct Node *head, struct Node *new_node) {
    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
    return head;
}

// 在链表尾部删除一个节点
struct Node *delete_tail(struct Node *head) {
    if (head == NULL) {
        return head;
    }
    struct Node *cur = head;
    struct Node *prev = NULL;
    while (cur->next != NULL) {
        prev = cur;
        cur = cur->next;
    }
    if (prev == NULL) {
        head = NULL;
    } else {
        prev->next = NULL;
    }
    free(cur);
    return head;
}

// 创建一个新节点
struct Node *create_node(int value) {
    struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
    new_node->data = value;
    new_node->next = NULL;
    return new_node;
}

int main() {
    // 创建一个空链表
    struct Node *head = create_list();

    // 创建所有的节点
    struct Node *node1 = create_node(1);
    struct Node *node2 = create_node(2);
    struct Node *node3 = create_node(3);
    struct Node *node4 = create_node(4);

    // 插入所有节点
    head = insert_node(head, node1)
head = insert_node(head, node2);
head = insert_node(head, node3);
head = insert_node(head, node4);

// 在链表末尾插入一个节点
struct Node *new_node1 = create_node(5);
head = insert_tail(head, new_node1);

// 在链表中删除一个节点
head = delete_node(head, 3);

// 在链表头部插入一个节点
struct Node *new_node2 = create_node(0);
head = insert_head(head, new_node2);

// 在链表头部删除一个节点
head = delete_head(head);

// 在链表尾部插入一个节点
struct Node *new_node3 = create_node(6);
head = insert_tail(head, new_node3);

// 在链表尾部删除一个节点
head = delete_tail(head);

// 输出链表中所有节点的值
struct Node *cur = head;
while (cur != NULL) {
    printf("%d ", cur->data);
    cur = cur->next;
}
printf("\n");

// 释放所有节点
cur = head;
while (cur != NULL) {
    struct Node *temp = cur;
    cur = cur->next;
    free(temp);
}

return 0;
}

在这个实现中，我们使用 create_node 函数创建一个新节点。 insert_node 函数用于将新节点插入链表中。 delete_node 函数用于删除链表中的某个节点。 insert_head 和 delete_head 分别用于在链表头部插入和删除节点。 insert_tail 和 delete_tail 分别用于在链表尾部插入和删除节点。

在 main 函数中，我们首先创建一个空链表。然后创建所有的节点，并将它们插入链表中。接下来，我们在链表末尾插入一个节点，删除链表中的某个节点，插入一个节点到链表头部，删除链表头部的节点，插入一个节点到链表尾部，删除链表尾部的节点。最后，我们输出链表中所有节点的值，然后释放所有节点的内存。

L念安dd
关注
  • 4
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
c语言链表创建
10-23
详细用c语言创建链表，通俗易懂链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白了，链表就如同车链子一样，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“NULL”（表示“空地址”），链表到此结束。
C语言期末大作业——图书信息管理系统（C语言，单链表）.zip
最新发布
06-13
《C语言期末大作业——图书信息管理系统（C语言，单链表）》 这个项目是一个基于C语言实现的图书信息管理系统，它利用了数据结构中的单链表来存储和管理图书信息。在深入探讨这个系统之前，我们首先需要了解C语言和...
单链表的插入与删除
mmdev
12-21 575
参考：http://www.itxyz.net/3jk/c/2010/0820/11016.html 最近不是太忙，整理些东西，工作也许用得到。 在链表这种特殊的数据结构中，链表的长短需要根据具体情况来设定，当需要保存数据时向系统申请存储空间，并将数据接入链表中。对链表而言，表中的数据可以依此接到表尾或连结到表头，也可以视情况插入表中；对不再需要的数据，将其从表中删除并释放其所占空间，...
C语言创建链表
aixiaoli2923的博客
09-10 2193
一、链表中结点的存储 链表的结点左边一部分是存放的数据，右边一部分是后继指针指向下一个结点的地址。C语言中通常定义一个结构体类型来存储一个结点，如下： struct node { int data; struce node *next; //下一个结点的类型也是struct node，所以后继指针的类型也必须是struct node * };...
C语言—单链表的创建与插入操作
Char_kar的博客
01-02 2408
C语言—单链表的创建与插入操作
单链表之插入删除结点
无敌的专栏
07-30 2621
题：编程实现单链表删除结点。【美国某著名分析软件公司面试题】 解析：如果删除的是头结点，如下图所示。 则把head指针指向头结点的下一个结点，同时free P1结点，如下图所示。 。 如果删除的是中间结点，如下图所示。 则用P2的next指向P1的next同时，free P1，如下图所示。 。 答案：完整代码如下： // P167_example1.cpp
C语言期末大作业-图书信息管理系统（C语言，单链表）
05-09
《图书信息管理系统——基于C语言的单链表实现》 在IT领域，C语言作为一种基础且强大的编程语言，被广泛用于教学与实际项目开发。K12阶段的学生接触C语言，不仅能理解计算机底层工作原理，还能为后续学习更高级的...
精选_毕业设计_基于C语言的单链表客房管理系统_完整源码
03-05
本项目“基于C语言的单链表客房管理系统”就是一个很好的实例，它展示了如何利用C语言实现一个基本的数据结构——单链表，并运用到实际的管理系统中。 单链表是数据结构中的基础元素，它由一系列节点组成，每个节点...
C语言数据结构创建单链表，插入操作，删除操作，存取操作，查找操作的代码实现
LLF_ABC的博客
12-10 2262
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。一个单链表结点由以下两个域构成。数据域指针域datanext其中数据域data存放该结点的数据域的值，指针域存放该结点的后继结点的地址信息。关于单链表的主要操作有插入操作，删除操作，存取操作，查找操作等。如果想要去跑下面代码的实现，请先加上头文件和结构体声明以及全局变量，这里也附带了一个测试用的主函数。
C语言之创建链表
daitianjun的博客
10-16 4368
c语言单链表的创建过程分析
c语言创建链表
马力的博客
06-14 733
链表实现及相关算法1.数据结构2.链表初始化3.遍历链表4.排序（冒泡排序）5.插入元素6.删除元素7.完整代码 使用malloc函数动态分配内存创建链表，可以手动释放内存，顺便练习一下C语言数据结构。 1.数据结构 typedef struct node{ int date;//数据域 struct node * pNext;//指针域 }NODE, *PNODE; 2.链表初始化 //创建链表，返回链表的头指针 PNODE create_list(void) { int len; int
c语言链表的创建
m0_57529375的博客
10-31 2441
链表的优点1.可以随时利用指针读取 2.方便对于链表中数据的修改 基本结构组成：指针；一定的结构体。 需要的基本操作：内存动态管理 分配内存空间函数malloc void *malloc(unsigned int size);功能是在内存的动态存储区中分配一块长度为size的连续区域。如果分配成功，返回值为该区域的首地址。 ...
c语言———链表的创建
weixin_61375386的博客
02-28 922
最近刚想学习到链表这一块的知识，于是便敲了链表的创建 #include<stdio.h> #include<stdlib.h> struct node { int date; struct node* next; }; struct node* creade() { struct node* p = (struct node*)malloc(sizeof(struct node)); p->date = 1; p->next = NULL; return
链表创建 c语言,c语言创建链表
weixin_31110741的博客
05-19 411
#include #include typedef struct Node{int data;struct Node *next;}No;int main() { No *head; //头指针 int array[10]={0,1,2,3,4,5,6,7,8,9}; head=(No*)malloc(sizeof(No)); No *p=head; ...
[C语言]实现链表的创建，读取，插入和删除操作
m0_74198057的博客
07-21 526
通过C语言来构建一个简单链表，并实现链表的读取，插入和删除操作
c语言实现创建链表
The Coding World
04-16 6720
利用尾插法创建链表 #include #include //定义链表节点 struct Node { int data; struct Node *next; }node; int main() { struct Node *head, *pt, *p; head = pt = (struct Node *)malloc(sizeof(node)); scanf("%d",&pt-
C语言链表的插入
weixin_46073538的博客
03-01 2825
#include<stdio.h> #include<math.h> #define OK 1 #define ERROR -1 typedef int Status ; typedef int ElemType ; typedef struct Lnode{ ElemType data; /*数据域，保存结点的值 */ struct Lnode *next; /*指针域*/ } LNode; /
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

L念安dd

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值