入门：链表的基本操作

最新推荐文章于 2024-05-30 17:21:02 发布
最新推荐文章于 2024-05-30 17:21:02 发布
阅读量1.1w 收藏 139
点赞数 34
分类专栏： C语言 文章标签： 函数 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linwh8/article/details/49648601
版权

入门：链表的基本操作

标签：C语言 链表

By 小威威

1.写这篇博文的原因

C语言有三大重要部分：流程控制、函数、指针。
对于指针，单单了解它的简单应用是不够的，最重要的还是学习链表。许多参考书对链表的基本操作的概括还是不大完整的，所以在此通过这篇博文介绍链表的几种常用操作，以帮助初学者入门链表。

2.链表的基本操作主要有哪一些

1）链表的建立；
2）链表的输出；
3）链表结点的插入；
4）链表结点的删除；
5）链表各结点指向的倒置；
6）链表的粉碎。
补充：入门基本操作以后，可以进行其他操作：如各种类型的排序，这里就不介绍了，在以后的博文可能会介绍。

3.链表基本操作的完整代码

# include <stdio.h>
# include <stdlib.h>
struct student {  //  用结构体定义链表的结点
    int num;    //  学号
    float score;  //  分数
    struct student *next;  //  存储的是指向下一个结构体的地址
};
struct student *establish(void);  //  建立链表的函数的声明
struct student *lessen(struct student *head, int num);  //  删除结点的函数的声明
struct student *insert(struct student *head, int num, struct student *node);  //  插入结点的函数的声明
struct student *reserve(struct student *head);  //  链表指向倒置的函数的声明
void output(struct student *head);  //  输出链表的函数的声明
void deletelist(struct student *head);  //  粉碎链表的函数的声明
int n;  // 定义全局变量，表示链表中结点的个数
int main(void) {
    struct student *head;  // 定义链表的头指针
    int num, num2;  // num表示要删去的结点
    head = establish();  // 调用建立链表的函数
    output(head);  //  调用输出链表的函数
    printf("请输入你要删除的结点：\n");
    scanf("%d", &num);
    head = lessen(head, num);  //  调用删除结点的函数
    output(head);  //  调用输出链表的函数
    struct student *node = malloc(sizeof(struct student));  // 定义一个新的结点，并为他开辟一个空间
    printf("请输入需要插入新结点的数据：\n");
    scanf("%d%f", &node->num, &node->score);  // 给该新结点赋值
    printf("请输入要插入的位置（哪个结点之后）：\n");
    scanf("%d", &num2);  // 输入要插入的位置
    head = insert(head, num2, node);  // 调用插入结点的函数
    output(head);  // 调用输出的函数
    printf("现在对该链表的指向进行倒置\n");
    head = reserve(head);  // 调用链表指向倒置的函数
    output(head);  // 调用输出链表的函数
    deletelist(head);  //  调用粉碎链表的函数
    return 0;
}

struct student *establish(void) {  // 定义建立链表的函数
    struct student *p1, *p2, *head;  // 定义三个指针变量,p1、p2可以对相邻结点进行操作，head为头指针
    n = 0;  //  给n初始化，即结点为0
    p1 = p2 = malloc(sizeof(struct student));  // 给两个指针变量分配动态内存
    head = NULL;  // 一定要将头指针置空。(如果没有初始化，一旦没有执行循环,该函数就会直接返回没有初始化的头指针，即没用的头指针)
    printf("请输入数据(0 0结束)：\n");
    scanf("%d%f", &p1->num, &p1->score);  // 给结点赋值
    while (p1->num != 0) {  //  建立一个while循环，判断条件是检测p1－>num是否为0，以决定是否终止循环
        n += 1;  // 若不为0，则可建立新结点，即结点数＋1
        if (n == 1)  //  将第一个结点的地址赋给头指针
            head = p1;
        else  //  将p1的地址赋给p2，如此p1,p2就能实现对相邻结点的操作
            p2 = p1;
        p1 = malloc(sizeof(struct student));  // 建立新结点
        p2->next = p1;  // 把新结点的位置赋给新结点前的结点存储的地址区间内(也就是p2对应的结点)
        scanf("%d%f", &p1->num, &p1->score);  // 给新结点赋值
    }
    p2->next = NULL;  //  循环结束后,p2就是最后一个结点，故将其存储的地址区间置空
    free(p1);  // 此时的p1起到的是结束循环的作用，是一个没有作用的结点，应该删去，故清空其内存，并加以置空
    p1 = NULL;  //  将无作用的结点置空
    return head;  // 返回头指针
}
struct student *lessen(struct student *head, int num) { // 动态链表结点的删除函数
    struct student *p1, *p2 = NULL;//初始化，避免p2没有被初始化（在本程序中确实有可能）
    if (head == NULL) {
        printf("List is NULL\n");//先判断是否为空链表，如果是，返回头指针而不做其他操作
        return head;
    }
    p1 = head;//把头指针赋给p1
    while (p1->num != num && p1->next != NULL) { //while循环条件：结构体的数值不等于num且结构体地址不为NULL（即不对最后一个结点操作）
        p2 = p1; //用p2保存p1的地址，便于储存所要删除的结点的地址区间的内容
        p1 = p1->next; //结点后移
    }
    if (p1->num == num) { //判断该结点是否符合要求
        if (p1 == head) { //判断该结点是否为第一个结点
            head = p1->next; //如果删除的是第一个结点，则把第一个结点的地址区间的内容赋给head
            printf("Delete %d success\n", num);
        } else { //如果删除的不是第一个结点，则将所删除结点的地址区间内容赋给p2的地址区间
            p2->next = p1->next;
            printf("Delete %d success\n", num);
        }
        free(p1); //清空p1，即清空删除结点所占的内存
        p1 = NULL; //将p1置空，避免生成野指针
        n -= 1; //结点数减少一个
    } else {
        printf("Can't find the num in the list\n");
    }
    return head; //返回头指针
}
struct student *insert(struct student *head, int num, struct student *node) { //定义动态链表插入结点的函数
    struct student *p1; // 定义一个p1，相当于结构体指针的副本
    if (head == NULL) { // 倘若这是一个空链表，则加一个结点它就不是空链表了
        head = node; // 所以就把新结点的位置赋给头指针head
        node->next = NULL; // 将新结点的地址区间清空
        n += 1; // 结点数加1
    } else {  //如果不是空链表，则执行接下来的操作
        p1 = head; // 将头指针赋给p1，防止接下来的操作改变头指针的值
        while (p1->num != num && p1->next != NULL) // 用一个while循环对目标结点（新结点前面的结点）进行搜索
            p1 = p1->next; // 将链表推进
    }
    if (p1->num == num) { // 判断是否存在目标结点
        node->next = p1->next;  // 将node插入p1与原p1下一个结点之间，把p1指向下一结点的地址区间赋给node的地址区间
        p1->next = node; // 再把node的地址赋给p1的地址区间
        n += 1; // 结点数加一
    } else {
        printf("Cannot find the figure\n");  //  如果没有找到目标结点，则输出提示信息
    }
    return head;  //  返回头指针
}
struct student *reserve(struct student *head) {  //定义一个将链表指向倒置的函数
    struct student *p, *p1, *p2;  //  定义三个结构体指针变量，p用于暂时储存，p1,p2用于对相邻结点的操作
    p1 = NULL;  // p1指前面的结点(原链表)，刚开始赋NULL是为了让第一个结点(也就是倒置后的尾结点)的地址区间清空
    p2 = head;  // p2指后面的结点(原链表)，刚开始赋head是要通过p2对该链表进行操作
    while (p2 != NULL) {  // 定义一个while循环，第一是判断该链表是否为空链表，第二是判断是否到达了原先链表的尾结点
        p = p2->next;  // 先用p暂时储存p2所存储的下一个结点地址区间，目的是为了实现链表操作时结点的后移
        p2->next = p1;  // 然后把前面结点的地址赋给后面结点的地址区间，目的是使后一个结点指向前面的一个结点，以实现指向的倒置
        p1 = p2;   //  将p2位置赋给p1，因为结点后移时p1,p2的指向也要跟着后移
        p2 = p;   // 将下一个结点的位置赋给p2，完成结点的后移
    }
    head = p1;  //  循环结束时，p1对应的就是新链表的第一个结点，故将其地址赋给头指针
    return head;  //  返回头指针
}
void output(struct student *head) {  // 定义一个链表输出的函数
    struct student *p1;  // 定义结构体指针变量p1，用于结点的后移，以实现输出操作
    p1 = head;  // 将head赋给p1，以实现对该链表的操作
    while (p1 != NULL) {  // 建立一个while循环，结束条件是到达尾结点
        printf("%d\n%f\n", p1->num, p1->score);  // 输出结点中的数值部分
        p1 = p1->next;  // 将下一个结点的位置赋给p1
    }
    return;
}
void deletelist(struct student *head) {
    struct student *p1; // 定义结构体指针变量副本
    while (head != NULL) { // 建立一个while循环，条件是head不为空
        p1 = head->next;  // 将head所指向地址赋给p1
        free(head); // 然后释放head指向的结构体所占的内存
        head = p1; // 再把下一个结构体的地址赋给head
    }
}

4.各基本操作的函数

1）链表的建立

struct student *establish(void) {  // 定义建立链表的函数
    struct student *p1, *p2, *head;  // 定义三个指针变量,p1、p2可以对相邻结点进行操作，head为头指针
    n = 0;  //  给n初始化，即结点为0
    p1 = p2 = malloc(sizeof(struct student));  // 给两个指针变量分配动态内存
    head = NULL;  // 一定要将头指针置空。(如果没有初始化，一旦没有执行循环,该函数就会直接返回没有初始化的头指针，即没用的头指针)
    printf("请输入数据(0 0结束)：\n");
    scanf("%d%f", &p1->num, &p1->score);  // 给结点赋值
    while (p1->num != 0) {  //  建立一个while循环，判断条件是检测p1－>num是否为0，以决定是否终止循环
        n += 1;  // 若不为0，则可建立新结点，即结点数＋1
        if (n == 1)  //  将第一个结点的地址赋给头指针
            head = p1;
        else  //  将p1的地址赋给p2，如此p1,p2就能实现对相邻结点的操作
            p2 = p1;
        p1 = malloc(sizeof(struct student));  // 建立新结点
        p2->next = p1;  // 把新结点的位置赋给新结点前的结点存储的地址区间内(也就是p2对应的结点)
        scanf("%d%f", &p1->num, &p1->score);  // 给新结点赋值
    }
    p2->next = NULL;  //  循环结束后,p2就是最后一个结点，故将其存储的地址区间置空
    free(p1);  // 此时的p1起到的是结束循环的作用，是一个没有作用的结点，应该删去，故清空其内存，并加以置空
    p1 = NULL;  //  将无作用的结点置空
    return head;  // 返回头指针
}

2）链表的输出

void output(struct student *head) {  // 定义一个链表输出的函数
    struct student *p1;  // 定义结构体指针变量p1，用于结点的后移，以实现输出操作
    p1 = head;  // 将head赋给p1，以实现对该链表的操作
    while (p1 != NULL) {  // 建立一个while循环，结束条件是到达尾结点
        printf("%d\n%f\n", p1->num, p1->score);  // 输出结点中的数值部分
        p1 = p1->next;  // 将下一个结点的位置赋给p1
    }
    return;
}

3）链表结点的插入

struct student *insert(struct student *head, int num, struct student *node) { //定义动态链表插入结点的函数
    struct student *p1; // 定义一个p1，相当于结构体指针的副本
    if (head == NULL) { // 倘若这是一个空链表，则加一个结点它就不是空链表了
        head = node; // 所以就把新结点的位置赋给头指针head
        node->next = NULL; // 将新结点的地址区间清空
        n += 1; // 结点数加1
    } else {  //如果不是空链表，则执行接下来的操作
        p1 = head; // 将头指针赋给p1，防止接下来的操作改变头指针的值
        while (p1->num != num && p1->next != NULL) // 用一个while循环对目标结点（新结点前面的结点）进行搜索
            p1 = p1->next; // 将链表推进
    }
    if (p1->num == num) { // 判断是否存在目标结点
        node->next = p1->next;  // 将node插入p1与原p1下一个结点之间，把p1指向下一结点的地址区间赋给node的地址区间
        p1->next = node; // 再把node的地址赋给p1的地址区间
        n += 1; // 结点数加一
    } else {
        printf("Cannot find the figure\n");  //  如果没有找到目标结点，则输出提示信息
    }
    return head;  //  返回头指针
}

4）链表结点的删除

struct student *lessen(struct student *head, int num) { // 动态链表结点的删除函数
    struct student *p1, *p2 = NULL;//初始化，避免p2没有被初始化（在本程序中确实有可能）
    if (head == NULL) {
        printf("List is NULL\n");//先判断是否为空链表，如果是，返回头指针而不做其他操作
        return head;
    }
    p1 = head;//把头指针赋给p1
    while (p1->num != num && p1->next != NULL) { //while循环条件：结构体的数值不等于num且结构体地址不为NULL（即不对最后一个结点操作）
        p2 = p1; //用p2保存p1的地址，便于储存所要删除的结点的地址区间的内容
        p1 = p1->next; //结点后移
    }
    if (p1->num == num) { //判断该结点是否符合要求
        if (p1 == head) { //判断该结点是否为第一个结点
            head = p1->next; //如果删除的是第一个结点，则把第一个结点的地址区间的内容赋给head
            printf("Delete %d success\n", num);
        } else { //如果删除的不是第一个结点，则将所删除结点的地址区间内容赋给p2的地址区间
            p2->next = p1->next;
            printf("Delete %d success\n", num);
        }
        free(p1); //清空p1，即清空删除结点所占的内存
        p1 = NULL; //将p1置空，避免生成野指针
        n -= 1; //结点数减少一个
    } else {
        printf("Can't find the num in the list\n");
    }
    return head; //返回头指针
}

5）链表结点指向的倒置

struct student *reserve(struct student *head) {  //定义一个将链表指向倒置的函数
    struct student *p, *p1, *p2;  //  定义三个结构体指针变量，p用于暂时储存，p1,p2用于对相邻结点的操作
    p1 = NULL;  // p1指前面的结点(原链表)，刚开始赋NULL是为了让第一个结点(也就是倒置后的尾结点)的地址区间清空
    p2 = head;  // p2指后面的结点(原链表)，刚开始赋head是要通过p2对该链表进行操作
    while (p2 != NULL) {  // 定义一个while循环，第一是判断该链表是否为空链表，第二是判断是否到达了原先链表的尾结点
        p = p2->next;  // 先用p暂时储存p2所存储的下一个结点地址区间，目的是为了实现链表操作时结点的后移
        p2->next = p1;  // 然后把前面结点的地址赋给后面结点的地址区间，目的是使后一个结点指向前面的一个结点，以实现指向的倒置
        p1 = p2;   //  将p2位置赋给p1，因为结点后移时p1,p2的指向也要跟着后移
        p2 = p;   // 将下一个结点的位置赋给p2，完成结点的后移
    }
    head = p1;  //  循环结束时，p1对应的就是新链表的第一个结点，故将其地址赋给头指针
    return head;  //  返回头指针
}

6）链表的粉碎

void deletelist(struct student *head) {
    struct student *p1; // 定义结构体指针变量副本
    while (head != NULL) { // 建立一个while循环，条件是head不为空
        p1 = head->next;  // 将head所指向地址赋给p1
        free(head); // 然后释放head指向的结构体所占的内存
        head = p1; // 再把下一个结构体的地址赋给head
    }

5.需要注意的地方

1.分配动态内存要注意释放并清空；
2.某些指针变量的初始化；
3.建立链表完成后记得将最后一个结点的地址区间置空；同样的，指向倒置时，记得将第一个结点的地址赋给头指针。

以上内容皆为本人观点，欢迎大家提出意见，共同探讨！

小威威__
关注
  • 34
    点赞
  • 踩
  • 139
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
C语言链表的学习
Flylily9997的博客
07-20 121
在学习链表的时候，有一些很重要的概念，之前一直没有弄清楚，后来经师父点拨，现在终于有点顿悟了，这些关键的点在百度上都没有人提及，却是我一直很疑惑的一点，所以总结在这里，以免日后遗忘. 在链表中我们基本的操作主要是创建链表，插入链表和删除打印链表等。但是他们是如何运作的，即使看再多的代码，没有理解也是白搭 首先要了解: 链表主要是由节点经由内部指针一环扣一环的连接构成；每个节点是由结构
双向链表(结构体+指针)
肘子的博客
08-02 5875
首先当然得了解单向链表了 传送门 首先，表中的各个元素称作“结点”。双向链表的结点时结构体，有数据本体，指向前一元素的指针prev以及指向后一元素的指针next组成。这些结构体通过指针构成一个链表，就形成了双向链表。 struct node{ int key; node *prev,*next;//注意不是node *prev,next }; 另外，在表头设置一个特殊...
3.1-链表介绍
一个好人的博客
06-05 308
Linked List,链表是有序列表,链表我们一般都会约定存在一个头节点和n个数据节点 头结点 : 存放的是链表的第一个数据节点的内存地址,根据头结点,我们可以找到第一个数据节点 数据结点 : 点存放的就是我们存放在链表当中的数据,但是要注意的是,每个数据节点还会存放下一结点的地址**(数据+下一结点地址)** 但是实际中,我们不会单独设置一个特殊的结构作为头结点,也就是说,头节点和数据结点只是功能上的不同,物理结构上是一样的,都是 data域 : 存储数据 next域 : 指向下一个结点 .
数据结构———链表
最新发布
2301_80097874的博客
05-30 362
int data;}Node;
链表学习总结
qq_42880126的博客
03-29 97
链表的定义、插入、删除、查找以及销毁知识及相关代码。
数据结构之顺序表与链表的基本操作
m0_55380558的博客
03-31 3379
有完整源码 文章目录 目录 文章目录 前言 一、基本功能 二、模块代码 2.1一级菜单 2.2二级菜单（顺序表 sqlist） 2.2.2 建立顺序表 2.2.3访问数据（第N个数据 （顺序表）） 2.2.4插入数据（插入到某个位置（顺序表）） 2.2.5删除数据（删除第N个数据（顺序表）） 2.2.6求表长（顺序表） 2.3 二级菜单（链表 ListNode,*LinkList） 2.3.1 头插法建立链表 2.3.2尾插...
python单向链表的基本操作细节（小白入门）
12-21
### 一、链表基本概念 1. **链式存储**：链表中的数据项不需要按照顺序存储，它们通过节点间的引用相连。 2. **动态长度**：链表的长度可以随时改变，因为添加或删除节点仅涉及节点间的引用更新，不需要移动其他...
关于入门单链表的基本操作
04-01
单链表是数据结构中的基础概念，它是线性数据结构的一种形式，由...通过阅读"关于入门单链表的基本操作.pdf"以及"注意.pdf"、"注意下.pdf"、"说明.pdf"等文件，你可以获得更详细的指导和示例，以加深对这一主题的理解。
数据结构链表入门.docx
01-13
1. 链表基本概念： 链表不同于数组，它不连续存储元素，而是由一系列称为节点的结构组成，每个节点包含数据和指向下一个节点的指针。在C++中，我们可以用结构体来定义一个链表节点。例如： ```cpp struct Student {...
Java链表（Linked List）基本原理与实现方法入门示例
08-19
Java链表（Linked List）基本原理与实现方法入门示例 Java链表（Linked List）是一种基础而且重要的数据结构，在Java程序设计中广泛应用。本文将对Java链表（Linked List）的基本原理与实现方法进行详细介绍，并...
整数链表
07-11
在教学环境中，整数链表是计算机科学入门课程中常见的数据结构练习，帮助学生理解链式存储和动态内存管理的基本概念。通过完成整数链表的作业，学生可以更好地掌握这些核心概念，并为学习更复杂的算法和数据结构打下...
[数据结构] 链表(图文超详解讲解)
积跬步以至千里
09-30 3154
根据本文对链表的介绍后大家能对链表有更深的理解相信大家在过后时间能够保持求学的态度,我们一起加油!offer拿到手软!对博主感兴趣可以关注博主,我会继续更新博客,努力完善我的文章内容不会辜负大家的期待!
链表的基本操作
09-20 5727
链表的基本概念以及分配内存空间 1.创建链表 把每个结点的next指针指向下一个结点的地址即可。 程序代码： #include<cstdio> //#include<stdlib> struct node { int data; //数据域 node* next; // 指针域 }; //创建链表 node* create(int Array[...
【C语言】链表及单链表基本操作
热门推荐
swag_wg的博客
04-29 12万+
1、什么是链表？链表的分类？ 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 数据结构中： 2、链表的分类 共有8种链表结构 ...
单链表的基本操作(头结点)
我的梦
11-06 1万+
本篇博客主要是对线性链表的基本实现，因此无法摆脱链表的基本缺点，比如无法快速定位前驱、无法快速确定元素个数等等。当然优点是能够快速对链表进行学习。本篇博客将网络上对单链表的各种操作进行实现，方便大家学习，如有错误，不吝指正！
链表及其基本操作
qcy的博客
05-30 605
1.链表的定义 链表：由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 //我们用结构体去存储每一个节点 //此处进行结构体的定义并进行重命名 typedef struct Node { int data; struct Node*next; }Node; 2.创建单链表 创建单链表常见的有头插法和尾插法两种，下面我们进行简单介绍： (1).头插法 步骤：(假设要加入的新节点的数据域是x) 1.创建头节点head，并且将头结点hea
C语言链表程序流程图,链表操作程序(完整)C语言
weixin_42523907的博客
05-18 1536
链表操作程序(完整)C语言#include#include#include/*定义结构体*/struct student{int num;float score;struct student *next;};/*创建一个只有头结点的空链表*/struct student *create_head(){struct student *head;head=(struct student*)malloc...
FPGA笔记之verilog语言（基础语法篇）
DBLLLLLLLL的博客
07-07 5万+
FPGA笔记之verilog语言（基础语法篇） 写在前面： verilogHDL语言是面向硬件的语言，换句话说，就是用语言的形式来描述硬件线路。因此与C语言等软件语言不同，如果想要在实际的电路中实现，那么在进行verilog语言编写时，就需要提前有个硬件电路的构思和想法，同时，在编写verilog语言时，应该采用可综合的语句和结构。 1.verilog 的基础结构 1.1 verilog设计的基本...
数据结构——链表（图文）
Wiki~
11-06 3222
链表 文章目录链表数据结构插入元素为链表设立虚拟的头节点链表的查找链表的修改遍历输出删除操作测试结果源码 之前我们学习了基于数组实现的三种数据结构：动态数组、栈、队列。他们底层依赖于静态数组，通过resize方法使其变成动态的。但是我们所谓的动态时是从用户的出发角度来看的。接下来我们学习链表。他是真正的动态数据结构，也是最简单的动态数据结构（因为还有二分搜索树、Trie等相对复杂的）。 学习链表，...
C语言入门：链表解析与基本操作
然后，我们可以创建和操作链表，例如插入新学生数据： ```c Node* createNode(int id, float score) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->id = id; newNode->score = score; newNode->...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值