线性表文档之单链表

已于 2022-04-06 00:14:45 修改
阅读量2.7k 收藏 15
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 线性表 单链表
于 2022-04-05 21:46:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123978070
版权

单链表

定义

概念

线性表的链式存储称为单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外，还需要存储一个指向其后继元素的指针。

在这里插入图片描述

结构体

单链表结点由一个数据域和一个指针域组成，其中数据域存储当前节点的数据值，而指针域存储当前节点的后继节点的地址。如图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tKp6eVU5-1649166081652)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220328220754976.png)]

单链表结点的结构体如下：

typedef struct LNode {
    int data;// 存放结点数据域，默认是 int 类型，可以修改为其他类型
    struct LNode* next;// 存放结点指针域，指向后继节点的指针
} LNode;// 定义单链表结点类型

特点

单链表的特点如下：

  • 链式存储线性表时，不需要使用地址连续的存储元素，即不要求逻辑上相邻的元素在物理位置上也相邻。
  • 单链表由于是通过『链』建立起的数据元素之间的逻辑关系，插入和删除操作不需要移动元素，只需要修改链结点指针域的指向。
  • 因为单链表的元素是离散地分布在存储空间中，所以单链表不能随机存取，如果要找到某个数据元素，最坏情况下需要遍历整个单链表。
  • 单链表存储数据不需要大量连续存储空间，但单链表结点除了存储数据值之外，还附加有指针域，就存在浪费存储空间的缺点。

顺序表和单链表的区别：

顺序表单链表
是否逻辑相邻是是
是否物理相邻是否
存储空间是否连续连续离散
是否存在空间浪费如果确定要存储的数据多少，那么使用顺序表不存在明显的空间浪费；如果不确定要存储的数据多少，那么使用顺序表可能有较大的空间浪费。如果确定要存储的数据多少，那么使用单链表相比顺序表存在空间浪费，因为还需要存储指针域；如果不确定要存储的数据多少，那么使用单链表更划算。
访问随机元素的时间复杂度支持下标访问元素，时间复杂度为 O(1)必须从头开始遍历整个单链表直到找到某元素为止，访问随机元素的平均时间复杂度为 O(n)
随机位置插入和删除元素的时间复杂度由于顺序表的元素是连续存储的，如果要在特定位置插入或删除元素时要将它之后的元素全部后移或前移一个元素的位置，时间开销较大。平均时间复杂度为 O(n)。单链表在插入或删除元素时，只需要改变它的前驱节点和插入或删除元素的指针指向即可。时间复杂度为 O(1)。
使用建议如果查询操作比较频繁则使用顺序表比较好。如果插入或删除操作比较频繁时则使用单链表较好。

基本操作

注：如无特殊说明，下面关于单链表的所有操作都是基于带头结点的单链表。完整代码请参考：

概述

注：下面都是 C 语言代码，所以如果要对单链表进行删除或新增操作，链表参数都是双指针。如果要使用 C++ 的引用则改成 *&。一般如果是考研建议使用 & 引用，避免双指针。

单链表的常见基本操作如下：

  • void init(LNode **list)：初始化单链表。其中 list 表示未初始化的单链表。
  • LNode *createByHead(LNode **list, int nums[], int n)：通过头插法创建单链表。其中 list 是未初始化的单链表；nums 表示待插入到单链表中的数据数组；n 表示数组 nums 数组长度。返回创建成功的单链表。
  • LNode *createByTail(LNode **list, int nums[], int n)：通过尾插法创建单链表。其中 list 是未初始化的单链表；nums 表示待插入到单链表中的数据数组；n 表示数组 nums 数组长度。返回创建成功的单链表。
  • LNode *findByNum(LNode *list, int i)：查找单链表中第 i 个结点。其中 list 是单链表；i 是结点序号，从 1 开始，支持的范围是 [1, length]。如果查找成功则返回第 i 个位置的结点，否则返回 NULL。
  • LNode *findByEle(LNode *list, int ele)：查找单链表中等于指定值 ele 的结点。其中 list 是单链表；ele 是指定值。如果查找成功则返回等于该值的第一个结点，否则返回 NULL。
  • int insert(LNode **list, int i, int ele)：在单链表指定 i 位置插入新元素 ele。其中 list 是已经初始化的单链表；i 是链表节点序号，从 1 开始；ele 是待插入新节点的数据值。如果插入成功则返回 1，否则返回 0。
  • int remove(LNode **list, int i, int *ele)：删除单链表中指定 i 位置的元素，并且用 ele 来存储被删除元素。其中 list 是已经初始化的单链表；i 是链表节点序号，从 1 开始；ele 是用来存放被删除节点的数据值。如果删除成功则返回 1，否则返回 0。
  • int removeEle(LNode **list, int ele)：删除单链表中第一个数据值为 ele 的元素。其中 list 是已经初始化的单链表；ele 是待删除元素的数据值。如果删除成功则返回 1，否则返回 0。
  • void removeAllEle(LNode **list, int ele)：删除单链表中所有数据值为 ele 的元素。其中 list 是已经初始化的单链表；ele 是待删除元素的数据值。
  • int size(LNode *list)：计算单链表的长度。其中 list 是已经初始化的单链表。返回单链表中元素个数。
  • int isEmpty(LNode *list)：判断单链表是否为空。其中 list 是已经初始化的单链表。如果单链表为空则返回 1，否则返回 0。
  • void clear(LNode **list)：清空单链表。其中 list 是待清空的单链表。
  • void print(LNode *list)：打印单链表所有节点。其中 list 是待打印的单链表。

init

初始化单链表。如果是带头结点的单链表，初始化是创建头结点并将头结点的 next 指针指向 NULL；如果是不带头结点的单链表，初始化是将头指针指向 NULL。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ugdmJb5i-1649166081656)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220329223345937.png)]

实现代码如下：

/**
 * 初始化单链表
 * @param list 待初始化的单链表
 */
void init(LNode **list) {
    // 创建头结点，分配空间
    *list = (LNode *) malloc(sizeof(LNode));
    // 同时将头节点的 next 指针指向 NULL，因为空链表没有任何节点
    (*list)->next = NULL;
}

如果是使用 C++ 中的引用，则代码如下：

/**
 * 初始化单链表
 * @param list 待初始化的单链表
 */
void init(LNode *&list) {
    // 创建头结点，分配空间
    list = (LNode *) malloc(sizeof(LNode));
    // 同时将头节点的 next 指针指向 NULL，因为空链表没有任何节点
    list->next = NULL;
}

如果是不带头结点的初始化代码如下：

/**
 * 初始化不带头节点的单链表
 * @param list 待初始化的单链表
 */
void init(LNode *&list) {
    // 将头指针直接置为 NULL，表示空单链表
    list = NULL;
}

createByHead

通过头插法批量插入元素然后创建一个非空单链表。所谓的头插法就是每次插入一个新元素都是插入在第一个结点的位置，无论单链表是否带有头节点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ffeIC8sp-1649166081658)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220329225506242.png)]

实现步骤：

  • 对链表进行初始化。注意，是带头结点的单链表。
  • 循环遍历数组中的每个元素，然后根据数组元素创建单链表结点，创建新节点时将数组元素值赋给结点数据域，将新节点的指针域指向 NULL。
  • 将创建的新节点的 next 指针域指向单链表的第一个节点，然后将单链表的头结点的 next 指针指向新节点。

注：

  • 为什么不直接新节点的指针域？是因为保持创建新节点的完整性，便于知道做了哪些操作。
  • 在进行单链表插入操作时，先处理新节点的 next 指针域，再处理前驱节点的 next 指针域指向新节点。即先后再前。

实现代码如下：

/**
 * 通过头插法创建单链表
 * @param list 单链表
 * @param nums 数据数组
 * @param n 数组长度
 * @return 创建成功的单链表
 */
LNode *createByHead(LNode **list, int nums[], int n) {
    // 1.初始化单链表
    // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
    *list = (LNode *) malloc(sizeof(LNode));
    (*list)->next = NULL;

    // 2.通过循环将数组中所有值通过头插法插入到单链表中
    for (int i = 0; i < n; i++) {
        // 2.1 创建新节点，并指定数据域和指针域
        // 2.1.1 创建新结点，分配空间
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        // 2.1.2 给新节点的数据域指定值
        newNode->data = nums[i];
        // 2.1.3 给新节点的指针域指定为 null
        newNode->next = NULL;

        // 2.2 将新节点插入到单链表的头部，但是在头结点的后面
        // 2.2.1 获取到单链表的第一个节点，即头结点的后继节点
        LNode *firstNode = (*list)->next;// 单链表的第一个节点
        // 2.2.2 将头结点的 next 指针指向新节点
        newNode->next = firstNode;
        // 2.2.3 将新节点的 next 指针指向原单链表的第一个节点，此时新节点成为了单链表头结点的后继节点
        (*list)->next = newNode;
    }
    return *list;
}

createByTail

通过尾插法批量插入元素然后创建一个非空单链表。所谓的尾插法就是每次将新节点插入到链表的尾部。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nGtGTA72-1649166081663)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220329231054572.png)]

以 [1, 2, 3, 4, 5] 为例使用尾插法创建单链表步骤如图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pIDgONXv-1649166081667)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220329232614922.png)]

实现步骤：

  • 初始化单链表。
  • 设置一个变量来记录单链表的尾结点 tailNode，初始为单链表的头结点。
  • 循环遍历数组中的每个元素，然后根据数组元素创建单链表结点，创建新节点时将数组元素值赋给结点数据域，将新节点的指针域指向 NULL。
  • 将尾结点 tailNode 的 next 指针指向新结点，然后将新节点记录为新的尾节点。

实现代码如下：

/**
 * 通过尾插法创建单链表
 * @param list 单链表
 * @param nums 创建单链表时插入的数据数组
 * @param n 数组长度
 * @return 创建好的单链表
 */
LNode *createByTail(LNode **list, int nums[], int n) {
    // 1.初始化单链表
    // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
    *list = (LNode *) malloc(sizeof(LNode));
    (*list)->next = NULL;

    // 尾插法，必须知道链表的尾节点（即链表的最后一个节点），初始时，单链表的头结点就是尾节点
    // 因为在单链表中插入节点我们必须知道前驱节点，而头插法中的前驱节点一直是头节点，但尾插法中要在单链表的末尾插入新节点，所以前驱节点一直都是链表的最后一个节点，而链表的最后一个节点由于链表插入新节点会一直变化
    LNode *node = (*list);

    // 2.循环数组，将所有数依次插入到链表的尾部
    for (int i = 0; i < n; i++) {
        // 2.1 创建新节点，并指定数据域和指针域
        // 2.1.1 创建新节点，为其分配空间
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        // 2.1.2 为新节点指定数据域
        newNode->data = nums[i];
        // 2.1.3 为新节点指定指针域，新节点的指针域初始时设置为 null
        newNode->next = NULL;

        // 2.2 将新节点插入到单链表的尾部
        // 2.2.1 将链表原尾节点的 next 指针指向新节点
        node->next = newNode;
        // 2.2.2 将新节点置为新的尾节点
        node = newNode;
    }
    return *list;
}

findByNum

查找单链表中第 i 个结点。以 list=[1, 2, 3, 4, 5]; i=3 为例如图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WJyXa9Kd-1649166081669)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220401232457427.png)]

实现步骤：

  • 参数校验，i 的范围必须在 [1, length]，否则就是非法参数，返回 NULL。
  • 从头结点 node 开始，每次前进一步，前进 i 次，循环结束后 node 刚好指向第 i 个结点。

实现代码如下：

/**
 * 发现单链表中第 i 个结点
 * @param list 单链表
 * @param i 指定序号位置，从 1 开始
 * @return 如果第 i 个结点存在则返回，否则返回 NULL
 */
LNode *findByNum(LNode *list, int i) {
    // 0.参数校验，序号 i 必须在 [1, length] 范围内
    if (i < 1 || i > size(list)) {
        return NULL;
    }

    // 1.从头到尾扫描单链表，找到第 i 个结点
    LNode *node = list;// 注意，从头结点开始
    while (i > 0) {
        node = node->next;
        i--;
    }
    return node;
}

findByEle

查找单链表中结点值等于 ele 的结点。以 list=[11, 22, 33, 44, 55]; ele=33 为例如图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hNYu44e3-1649166081673)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220401232957460.png)]

实现步骤：

  • 从头到尾扫描单链表所有结点，比较结点值，然后返回单链表中第一个结点值等于 ele 的结点。如果单链表存在等于该值的结点，则返回 NULL。

实现代码如下：

/**
 * 查找单链表中等于指定值 ele 的结点
 * @param list 单链表
 * @param ele 指定值
 * @return 如果单链表中有等于值 ele 的结点则返回该结点，否则返回 NULL
 */
LNode *findByEle(LNode *list, int ele) {
    // 变量，记录链表结点，初始为链表第一个结点
    LNode *node = list->next;
    // 从头到尾扫描单链表所有结点，判断结点值
    while (node != NULL) {
        // 如果当前结点的值等于 ele，则返回
        if (node->data == ele) {
            return node;
        }
        // 否则继续下一个结点的判断
        node = node->next;
    }
    // 如果链表中不存在值等于 ele 的结点，则直接返回 NULL
    return NULL;
}

insert

在顺序表 list 的第 i （1<=i<=length）个位置插入新元素 ele。若 index 的输入不合法，则返回 0，表示插入失败。否则，找到第 i-1 个结点 iPreNode，然后创建新节点 newNode，将新结点的 next 指针域指向原 iPreNode->next，再将 iPreNode 结点的 next 指针域指向新节点 newNode。如果插入成功则返回 1。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uzvaxJES-1649166081675)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220329234028512.png)]

以 list=[1, 2, 3, 4, 5]; i=3; ele=66 为例，步骤如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-712lxnj7-1649166081677)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220329235520737.png)]

实现步骤：

  • 参数校验，判断序号 i 的合法性。如果超出 [1, length] 范围则返回 0 表示插入失败。
  • 通过循环找到第 i 个结点的前驱结点 iPreNode。
  • 将新结点插入到链表中。即创建新结点 newNode，然后将新结点 newNode 的 next 指针域指向原第 i 个结点（即 iPreNode->next 结点），再将第 i-1 个结点（即 iPreNode 结点）的 next 指针域指向新结点 newNode。
  • 插入成功后，返回 1。

实现代码如下：

/**
 * 在单链表的第 i 个结点（从 1 开始）前插入一个结点
 * @param list 单链表
 * @param i 节点序号，从 1 开始
 * @param ele 待插入的数据
 * @return 如果插入成功则返回 1，如果插入失败则返回 0
 */
int insert(LNode **list, int i, int ele) {
    // 0.校验参数
    if (i < 1 || i > size(*list) + 1) {// 当 i=1 并且单链表为空时也能有效插入
        return 0;
    }

    // 1.计算第 i 个节点的前驱节点。注意，第一个节点的前驱节点是头结点
    // 1.1 声明三个变量
    LNode *iPreNode = *list;// 用来保存第 i 个节点的前驱节点，初始时链表第一个节点的前驱节点是头结点
    LNode *node = (*list)->next;// 用来保存链表中的每一个节点为了遍历循环，初始时链表的第一个节点
    int count = 1;// 计数器，记录遍历次数，初始为 1 而不能是 0，因为 i 表示节点的序号（序号从 1 开始的）
    // 1.2 找到第 i 个节点的前驱节点，循环 i-1 次
    while (count < i) {
        // 1.2.1 计数器加 1，表示已经遍历 1 次
        count++;
        // 1.2.2 保存当前节点为前驱节点
        iPreNode = node;
        // 1.2.3 继续下一个节点
        node = node->next;
    }

    // 2.将新节点插入到链表中
    // 2.1 创建新节点
    // 2.1.1 为新节点分配空间
    LNode *newNode = (LNode *) malloc(sizeof(LNode));
    // 2.1.2 为新节点指定数据域
    newNode->data = ele;
    // 2.1.3 为新节点指定指针域，初始时都指向 null
    newNode->next = NULL;
    // 2.2 将新节点连接到链表中
    // 2.2.1 将新节点的 next 指针指向第 i 个节点的前驱节点的后继节点（实际上就是第 i 个节点）上
    newNode->next = iPreNode->next;
    // 2.2.2 将第 i 个节点的 next 指针指向新节点
    iPreNode->next = newNode;
    return 1;
}

remove

删除单链表指定位置 i 的结点，并且将被删结点的值保存到 ele 中返回。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LBtICKCP-1649166081683)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220330212854941.png)]

以 list=[1, 2, 3, 4, 5]; i=3 为例，步骤如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mLXtwB7Z-1649166081688)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220330213652315.png)]

实现步骤：

  • 参数校验，指定位置 i 必须是合法的参数，范围在 [1, length] 之间，包含边界。
  • 找到第 i 个结点的前驱结点 iPreNode（即第 i-1 个结点），并根据 iPreNode 得到第 i 个结点 iNode（即 iPreNode->next 结点）。
  • 然后将 iPreNode 结点的 next 指针指向 iNode 结点的后继结点，这样就断开了第 i 个结点在链表中的连接，最后返回 iNode 结点的数据值给 ele并调用 free 函数释放空间，完成删除返回 1。

实现代码如下：

/**
 * 删除单链表中第 i 个结点
 * @param list 单链表
 * @param i 节点序号，从 1 开始
 * @param ele 被删除节点的数据
 * @return 如果删除成功则返回 1，如果删除失败则返回 0
 */
int remove(LNode **list, int i, int *ele) {
    // 0.校验参数
    if (i < 1 || i > size(*list)) {
        return 0;
    }

    // 1.计算第 i 个节点的前驱节点。注意，第一个节点的前驱节点是头结点
    // 1.1 声明三个变量
    LNode *iPreNode = *list;// 用来保存第 i 个节点的前驱节点，初始时链表第一个节点的前驱节点是头结点
    LNode *node = (*list)->next;// 用来保存链表中的每一个节点为了遍历循环，初始时链表的第一个节点
    int count = 1;// 计数器，记录遍历次数，初始为 1 而不能是 0，因为 i 表示节点的序号（序号从 1 开始的）
    // 1.2 找到第 i 个节点的前驱节点，循环 i-1 次
    while (count < i) {
        // 1.2.1 计数器加 1，表示已经遍历 1 次
        count++;
        // 1.2.2 保存当前节点为前驱节点
        iPreNode = node;
        // 1.2.3 继续下一个节点
        node = node->next;
    }

    // 2.删除第 i 个节点
    // 2.1 得到第 i 个节点
    LNode *iNode = iPreNode->next;
    // 2.2 保存被删除节点的数据
    *ele = iNode->data;
    // 2.3 删除第 i 个节点，即将第 i 个节点的前驱节点的 next 指针指向第 i 个节点的后继节点
    iPreNode->next = iNode->next;
    // 2.4 释放被删除节点的空间
    free(iNode);

    return 1;
}

removeEle

删除单链表中第一个值等于 ele 的结点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LMwliYMs-1649166081690)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220330214153260.png)]

以 list=[1, 2, 3, 4, 5]; ele=4 为例，步骤如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lE2t2VCB-1649166081691)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220330215536559.png)]

实现步骤：

  • 设定两个变量 node 和 pre，其中 node 记录链表中的每一个结点（从单链表的第一个结点开始）直到遇到值等于 ele 的结点；而 pre 则记录 node 结点的前驱结点，便于进行删除 node 结点的操作。初始时 node 指向单链表的第一个结点，pre 指向链表的头结点。
  • 从第一个结点开始扫描单链表，如果发现正在遍历的结点 node 的数据域等于 ele，则删除 node 结点（即 pre->next=node->next），删除 node 结点之后就释放它的空间，然后返回 1 表示删除成功。

实现代码如下：

/**
 * 删除单链表中指定值的结点。
 * 注意，只会删除找到的第一个节点，如果有多个节点的值都等于指定值则只会删除第一个。
 * @param list 单链表
 * @param ele 指定值
 * @return 如果删除成功则返回 1，否则返回 0
 */
int removeEle(LNode **list, int ele) {
    // 链表的第一个节点
    LNode *node = (*list)->next;
    // 保存前驱节点，链表第一个节点的前驱节点是头结点
    LNode *pre = *list;
    // 循环单链表
    while (node != NULL) {
        // 发现待删除的节点
        if (node->data == ele) {
            // 删除节点，即将被删除节点的前驱节点的 next 指针指向被删除节点的后后继节点
            pre->next = node->next;
            // 释放被删除节点的空间
            free(node);
            return 1;
        }
        pre = node;
        node = node->next;
    }
    return 0;
}

removeAllEle

删除单链表中所有值为 ele 的结点，而非 removeEle 中只删除第一次出现值为 ele 的结点。以 list=[1, 2, 2, 3, 2, 4, 2]; ele=2 为例，步骤如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SobFMASU-1649166081693)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220330223033924.png)]

实现步骤：

  • 声明两个变量 node 和 pre，其中 node 记录链表中的每个结点，而 pre 记录 node 结点的前驱结点。初始时 node 指向单链表的第一个结点，pre 指向单链表的头结点。
  • 从单链表的第一个结点开始扫描单链表中的每一个结点 node。如果结点 node 的数据域等于 ele，则删除 node 结点（pre->next=node->next），并且 node 指向它的后继结点（node=node->next）；如果结点 node 的数据域不等于 ele，则更新 pre 和 node 变量的值，都指向它们的后继结点（pre=pre->next; node=node->next;）。
  • 直到扫描完成，删除单链表中所有值等于 ele 的结点。

实现代码如下：

/**
 * 删除单链表中结点值等于 ele 的所有结点
 * @param list 单链表
 * @param ele 待删除节点的值
 */
void removeAllEle(LNode **list, int ele) {
    // 链表的第一个节点
    LNode *node = (*list)->next;
    // 保存前驱节点，初始化链表第一个节点的前驱节点就是链表的头结点
    LNode *pre = *list;
    // 循环链表
    while (node != NULL) {
        // 如果查找到要删除的节点
        if (node->data == ele) {
            // 保存被删除的节点
            LNode *temp = node;
            // 删除节点，但这里不能用 pre->next = node->next; 来删除节点，其实也是可以的，将代码顺序改为：pre->next=node->next;node=node->next;，但需要考虑如何释放被删除节点的空间
            node = node->next;
            pre->next = node;
            // 释放被删除节点的空间
            free(temp);
        } else {
            // 如果没有找到则继续判断链表的下一个节点，但注意更新 node 和 pre
            node = node->next;
            pre = pre->next;
        }
    }
}

size

计算单链表的长度，即单链表中的结点个数。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4eCbkim4-1649166081694)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220330223537213.png)]

实现步骤：

  • 从单链表的第一个结点开始扫描，统计结点个数。注意，不把单链表头结点计算在内。

实现代码如下：

/**
 * 计算单链表的长度，即节点个数
 * @param list 单链表
 * @return 链表节点个数
 */
int size(LNode *list) {
    // 计数器，记录链表的节点个数
    int count = 0;
    // 链表的第一个节点
    LNode *node = list->next;
    // 循环遍历链表
    while (node != NULL) {
        // 计数器加1
        count++;
        // 继续链表的下一个节点
        node = node->next;
    }
    // 返回链表节点个数
    return count;
}

isEmpty

判断单链表是否为空，即单链表结点个数是否为零。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tm9dHBxF-1649166081699)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220330224226615.png)]

实现步骤：

  • 如果是带头结点的单链表判空条件则是 head->next==NULL；如果是不带头结点的单链表判空条件是 head==NULL。

实现代码如下：

/**
 * 判断单链表是否为空
 * @param list 单链表
 * @return 如果链表为空则返回 1，否则返回 0
 */
int isEmpty(LNode *list) {
    // 只需要判断链表的第一个节点是否存在即可
    return list->next == NULL;
}

clear

清空单链表所有结点。

实现步骤：

  • 从头到尾扫描单链表所有结点，然后调用 free 函数释放结点空间。

实现代码如下：

/**
 * 清空单链表
 * @param list 单链表
 */
void clear(LNode **list) {
    // 链表的第一个节点
    LNode *node = (*list)->next;
    // 循环遍历单链表所有节点
    while (node != NULL) {
        // 保存当前节点的下一个节点
        LNode *temp = node->next;
        // 释放当前节点的空间
        free(node);
        // 继续链表的下一个节点
        node = temp;
    }
    // 最重要的是，将链表的头结点的 next 指针指向 null
    (*list)->next = NULL;
}

print

打印单链表所有结点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9NQQ395s-1649166081703)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220330224546073.png)]

实现步骤：

  • 从头到尾扫描单链表，打印所有结点的数据域值。

实现代码如下：

/**
 * 打印链表的所有节点
 * @param list 单链表
 */
void print(LNode *list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list->next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

注意事项

关于链表结点

链表结点的数据类型是结构体类型，我们在创建单链表或者为单链表新增结点时，结点不是直接赋值使用的，而是需要先分配一片空间。例如：

// 创建新节点
LNode* newNode = (LNode*)malloc(sizeof(LNode));

结点是内存中一片由用户分配的存储空间，只有一个地址来表示它的存在，没有显式的名称。因此，如果我们要使用这片空间，那么我们会在创建链表结点空间时，同时定义一个指针，来存储这片空间的地址，并且常用这个指针的名称来作为结点的名称。有了这个指针，我们就可以访问或者修改这片空间的内容了。

如上代码用户分配了一片 LNode 类型的空间，也就是构造了一个 LNode 类型的结点，这时候定义了一个名字为 newNode 的指针来指向这个结点，同时也把 newNode 当作这个结点的名称。这里 newNode 有两个作用：一个表示结点，一个表示指向这个结点的指针。newNode 既是结点名又是指针名。

带头结点和不带头结点的单链表

在单链表每个结点中包含数据域和指针域，其中指针域用以指向其后继结点。为了操作上的方便，在单链表第一个结点之前附加一个结点，称为头结点。头结点的数据域可以不设任何信息，也可以记录表长等信息。因此在链表使用过程中可以区分带头结点的单链表和不带头结点的单链表。

带头结点的单链表：在带头结点的单链表中，头指针 head 指向头结点，头结点的数据域中不包含任何信息（也可以包含一些链表的如长度相关的信息），从头结点的后继结点（即单链表的第一个结点，也称为开始结点）开始存储数据信息。头指针 head 始终不等于 NULL，而 head->next==NULL 表示带头结点的单链表为空。

不带头结点的单链表：在不带头结点的单链表中，头指针 head 直接指向开始结点（即单链表的第一个结点），头指针 head 可以为 NULL，而当 head==NULL 时表示不带头结点的单链表为空。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pFfaTlGw-1649166081704)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220328222410412.png)]

注：带头结点和不带头结点的单链表最明显的区别是：带头结点的单链表中有一个结点（头节点）不存储信息（或者仅存储一些描述链表属性的信息，如表长），只是作为标志存在；而不带头结点的单链表的所有结点都存储信息。

头结点和头指针的区别：

  • 无论是带头结点还是不带头结点的单链表，头指针都指向链表的第一个结点（如果是带头结点的单链表则第一个结点是头节点；如果是不带头结点的单链表则第一个节点是开始节点），即图中的 head 指针。
  • 头结点是带头结点单链表中的第一个节点，只是作为链表存在的标志，数据域不存储信息，或者只存储一些链表属性信息。

单链表判空条件

带头结点的单链表为空的条件是：head->next==NULL。

不带头结点的单链表为空的条件是：head==NULL。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z3nX5b6c-1649166081707)(image-%E5%8D%95%E9%93%BE%E8%A1%A8/image-20220328224644770.png)]

引入头结点的好处

引入头结点后有如下两个优点：

  • 由于第一个数据节点的地址被存放在头结点的指针域中，因此在链表的第一个位置上的操作和在表的其他位置的操作（如新增节点或删除节点）一致，无须进行特殊处理。如下是带头结点单链表和不带头结点单链表插入新节点的代码：
/**
 * 在带头结点的单链表的指定位置插入新节点
 * @param list 带头结点的单链表
 * @param i 指定位置，序号，从 1 开始
 * @param ele 新节点的值
 */
void insertWithHead(LNode **list, int i, int ele) {
    // 0.校验参数

    // 1.计算第 i 个节点的前驱节点。注意，第一个节点的前驱节点是头结点
    // 1.1 声明三个变量
    LNode *iPreNode = *list;// 用来保存第 i 个节点的前驱节点，初始时链表第一个节点的前驱节点是头结点
    LNode *node = (*list)->next;// 用来保存链表中的每一个节点为了遍历循环，初始时链表的第一个节点
    int count = 1;// 计数器，记录遍历次数，初始为 1 而不能是 0，因为 i 表示节点的序号（序号从 1 开始的）
    // 1.2 找到第 i 个节点的前驱节点，循环 i-1 次
    while (count < i) {
        // 1.2.1 计数器加 1，表示已经遍历 1 次
        count++;
        // 1.2.2 保存当前节点为前驱节点
        iPreNode = node;
        // 1.2.3 继续下一个节点
        node = node->next;
    }

    // 2.将新节点插入到链表中
    // 2.1 创建新节点
    // 2.1.1 为新节点分配空间
    LNode *newNode = (LNode *) malloc(sizeof(LNode));
    // 2.1.2 为新节点指定数据域
    newNode->data = ele;
    // 2.1.3 为新节点指定指针域，初始时都指向 null
    newNode->next = NULL;
    // 2.2 将新节点连接到链表中
    // 2.2.1 将新节点的 next 指针指向第 i 个节点的前驱节点的后继节点（实际上就是第 i 个节点）上
    newNode->next = iPreNode->next;
    // 2.2.2 将第 i 个节点的 next 指针指向新节点
    iPreNode->next = newNode;
}

/**
 * 在不带头结点的单链表的指定位置插入新节点
 * @param list 不带头结点的单链表
 * @param i 定位置，序号，从 1 开始
 * @param ele 新节点的值
 */
void insertWithoutHead(LNode **list, int i, int ele) {
    // 0.校验参数

    // 1.创建新节点
    LNode *newNode = (LNode *) malloc(sizeof(LNode));
    newNode->data = ele;
    newNode->next = NULL;

    // 2.首先判断是否是空表
    // 2.1 如果是空表则将新节点作为链表的第一个结点
    if (*list == NULL) {
        *list = newNode;
    }
    // 2.2 如果不是空表
    else {
        // 2.2.1 继续判断插入位置是否是第一个位置，特殊处理
        if (i == 1) {
            // 2.2.1.1 那么将新节点的 next 指针指向原链表第一个结点
            newNode->next = *list;
            // 2.2.1.2 然后将新节点作为链表的第一个结点，即将让头指针指向新节点
            *list = newNode;
        }
        // 2.2.2 如果插入位置不是第一个，则找到第 i-1 个节点，将新节点插入到它的后面
        else {
            // 2.2.2.1 找到第 i 个节点的前驱节点
            LNode *iPreNode = *list;// 表示第一个节点
            LNode *node = (*list)->next;// 从第二个节点开始
            int count = 2;// 计数器，记录找到第几个节点了。注意，是从 2 开始的，因为第一个节点已经处理了
            while (count < i) {
                count++;
                iPreNode = node;
                node = node->next;
            }
            // 2.2.2.2 将新节点插入到 iPreNode 节点的后面
            newNode->next = iPreNode->next;
            iPreNode->next = newNode;
        }
    }
}
  • 无论单链表是否为空，其头指针 head 都指向头结点（空单链表头结点的指针域为 NULL；非空单链表头结点的指针域指向开始节点），因此空表和非空表的处理也得到了统一。如下是带头结点单链表和不带头结点单链表在链表尾部追加新节点的代码（完整代码请参考：附录一）：
/**
 * 向带头结点的单链表的尾部追加新节点
 * @param head 带头结点的单链表，head 是头指针指向头结点
 * @param ele 值
 */
void appendWithHead(LNode **head, int ele) {
    // 创建新节点并赋予数据域和指针域
    LNode *newNode = (LNode *) malloc(sizeof(LNode));
    newNode->data = ele;
    newNode->next = NULL;

    // 找到链表的尾节点
    LNode *node = *head;
    while (node->next != NULL) {
        node = node->next;
    }

    // 无论带头结点的单链表是空表还是非空表，都是在 node 节点的后面附加新节点
    // 将新节点插入到链表的尾部
    node->next = newNode;
}

/**
 * 向不带头结点的单链表的尾部追加新节点
 * @param head 不带头结点的单链表，head 是头指针指向开始节点
 * @param ele 值
 */
void appendWithoutHead(LNode **head, int ele) {
    // 创建新节点并赋予数据域和指针域
    LNode *newNode = (LNode *) malloc(sizeof(LNode));
    newNode->data = ele;
    newNode->next = NULL;
    // 判断是否是空表，如果是空表则将新节点作为链表
    if ((*head) == NULL) {
        // 将新节点作为链表的第一个节点
        *head = newNode;
    }
    // 如果不是空表则找到原链表的尾节点然后插入到其后
    else {
        // 找到链表的尾节点
        LNode *node = *head;
        while (node->next != NULL) {
            node = node->next;
        }
        // 将新节点插入到链表的尾部
        node->next = newNode;
    }
}

练习题

以下是一些单链表的练习题：

附录

附录一

带头结点的单链表和不带头结点的单链表在尾部追加新元素，对于空表和非空表的处理，完整代码如下：

#include <stdio.h>
#include <malloc.h>

/**
 * 单链表节点
 */
typedef struct LNode {
    /**
     * 单链表节点的数据域
     */
    int data;
    /**
     * 单链表节点的的指针域，指向当前节点的后继节点
     */
    struct LNode *next;
} LNode;

/**
 * 初始化带头结点的单链表
 * @param list 待初始化的单链表
 */
void initWithHead(LNode **list) {
    // 创建头结点，分配空间
    *list = (LNode *) malloc(sizeof(LNode));
    // 同时将头节点的 next 指针指向 NULL，因为空链表没有任何节点
    (*list)->next = NULL;
}

/**
 * 初始化不带头结点的单链表
 * @param list 待初始化的单链表
 */
void initWithoutHead(LNode **list) {
    // 直接赋为 NULL
    *list = NULL;
}


/**
 * 打印带头结点的单链表的所有节点
 * @param list 带头结点的单链表
 */
void printWithHead(LNode *list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list->next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

/**
 * 打印不带头结点的单链表的所有结点
 * @param list 不带头结点的单链表
 */
void printWithoutHead(LNode *list) {
    printf("[");
    // 不是空表才能打印链表所有节点
    if (list != NULL) {
        // 循环单链表所有节点，打印值
        while (list != NULL) {
            printf("%d", list->data);
            if (list->next != NULL) {
                printf(", ");
            }
            list = list->next;
        }
    }
    printf("]\n");
}

/**
 * 向带头结点的单链表的尾部追加新节点
 * @param head 带头结点的单链表，head 是头指针指向头结点
 * @param ele 值
 */
void appendWithHead(LNode **head, int ele) {
    // 创建新节点并赋予数据域和指针域
    LNode *newNode = (LNode *) malloc(sizeof(LNode));
    newNode->data = ele;
    newNode->next = NULL;

    // 找到链表的尾节点
    LNode *node = *head;
    while (node->next != NULL) {
        node = node->next;
    }

    // 无论带头结点的单链表是空表还是非空表，都是在 node 节点的后面附加新节点
    // 将新节点插入到链表的尾部
    node->next = newNode;
}

/**
 * 向不带头结点的单链表的尾部追加新节点
 * @param head 不带头结点的单链表，head 是头指针指向开始节点
 * @param ele 值
 */
void appendWithoutHead(LNode **head, int ele) {
    // 创建新节点并赋予数据域和指针域
    LNode *newNode = (LNode *) malloc(sizeof(LNode));
    newNode->data = ele;
    newNode->next = NULL;
    // 判断是否是空表，如果是空表则将新节点作为链表
    if ((*head) == NULL) {
        // 将新节点作为链表的第一个节点
        *head = newNode;
    }
    // 如果不是空表则找到原链表的尾节点然后插入到其后
    else {
        // 找到链表的尾节点
        LNode *node = *head;
        while (node->next != NULL) {
            node = node->next;
        }
        // 将新节点插入到链表的尾部
        node->next = newNode;
    }
}

int main() {
    // 创建带头结点的单链表
    LNode *A;
    initWithHead(&A);// 初始化带头结点的单链表
    appendWithHead(&A, 3);// 为带头结点的空单链表追加元素 
    appendWithHead(&A, 33);// 为带头结点的非空单链表追加元素
    appendWithHead(&A, 333);
    appendWithHead(&A, 3333);
    appendWithHead(&A, 33333);
    printWithHead(A);

    // 创建不带头结点的单链表
    LNode *B;
    initWithoutHead(&B);// 初始化不带头结点的单链表
    appendWithoutHead(&B, 4);// 为不带头结点的空单链表追加元素
    appendWithoutHead(&B, 44);// 为不带头结点的非空单链表追加元素
    appendWithoutHead(&B, 444);
    appendWithoutHead(&B, 4444);
    appendWithoutHead(&B, 44444);
    printWithoutHead(B);
}

执行结果如下：

[3, 33, 333, 3333, 33333]
[4, 44, 444, 4444, 44444]

附录二

带头结点的单链表和不带头结点的单链表在指定位置插入新元素，完整代码如下：

#include <stdio.h>
#include <malloc.h>

/**
 * 单链表节点
 */
typedef struct LNode {
    /**
     * 单链表节点的数据域
     */
    int data;
    /**
     * 单链表节点的的指针域，指向当前节点的后继节点
     */
    struct LNode *next;
} LNode;

/**
 * 初始化带头结点的单链表
 * @param list 待初始化的单链表
 */
void initWithHead(LNode **list) {
    // 创建头结点，分配空间
    *list = (LNode *) malloc(sizeof(LNode));
    // 同时将头节点的 next 指针指向 NULL，因为空链表没有任何节点
    (*list)->next = NULL;
}

/**
 * 初始化不带头结点的单链表
 * @param list 待初始化的单链表
 */
void initWithoutHead(LNode **list) {
    // 直接赋为 NULL
    *list = NULL;
}


/**
 * 打印带头结点的单链表的所有节点
 * @param list 带头结点的单链表
 */
void printWithHead(LNode *list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list->next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

/**
 * 打印不带头结点的单链表的所有结点
 * @param list 不带头结点的单链表
 */
void printWithoutHead(LNode *list) {
    printf("[");
    // 不是空表才能打印链表所有节点
    if (list != NULL) {
        // 循环单链表所有节点，打印值
        while (list != NULL) {
            printf("%d", list->data);
            if (list->next != NULL) {
                printf(", ");
            }
            list = list->next;
        }
    }
    printf("]\n");
}

/**
 * 在带头结点的单链表的指定位置插入新节点
 * @param list 带头结点的单链表
 * @param i 指定位置，序号，从 1 开始
 * @param ele 新节点的值
 */
void insertWithHead(LNode **list, int i, int ele) {
    // 0.校验参数

    // 1.计算第 i 个节点的前驱节点。注意，第一个节点的前驱节点是头结点
    // 1.1 声明三个变量
    LNode *iPreNode = *list;// 用来保存第 i 个节点的前驱节点，初始时链表第一个节点的前驱节点是头结点
    LNode *node = (*list)->next;// 用来保存链表中的每一个节点为了遍历循环，初始时链表的第一个节点
    int count = 1;// 计数器，记录遍历次数，初始为 1 而不能是 0，因为 i 表示节点的序号（序号从 1 开始的）
    // 1.2 找到第 i 个节点的前驱节点，循环 i-1 次
    while (count < i) {
        // 1.2.1 计数器加 1，表示已经遍历 1 次
        count++;
        // 1.2.2 保存当前节点为前驱节点
        iPreNode = node;
        // 1.2.3 继续下一个节点
        node = node->next;
    }

    // 2.将新节点插入到链表中
    // 2.1 创建新节点
    // 2.1.1 为新节点分配空间
    LNode *newNode = (LNode *) malloc(sizeof(LNode));
    // 2.1.2 为新节点指定数据域
    newNode->data = ele;
    // 2.1.3 为新节点指定指针域，初始时都指向 null
    newNode->next = NULL;
    // 2.2 将新节点连接到链表中
    // 2.2.1 将新节点的 next 指针指向第 i 个节点的前驱节点的后继节点（实际上就是第 i 个节点）上
    newNode->next = iPreNode->next;
    // 2.2.2 将第 i 个节点的 next 指针指向新节点
    iPreNode->next = newNode;
}

/**
 * 在不带头结点的单链表的指定位置插入新节点
 * @param list 不带头结点的单链表
 * @param i 定位置，序号，从 1 开始
 * @param ele 新节点的值
 */
void insertWithoutHead(LNode **list, int i, int ele) {
    // 0.校验参数

    // 1.创建新节点
    LNode *newNode = (LNode *) malloc(sizeof(LNode));
    newNode->data = ele;
    newNode->next = NULL;

    // 2.首先判断是否是空表
    // 2.1 如果是空表则将新节点作为链表的第一个结点
    if (*list == NULL) {
        *list = newNode;
    }
    // 2.2 如果不是空表
    else {
        // 2.2.1 继续判断插入位置是否是第一个位置，特殊处理
        if (i == 1) {
            // 2.2.1.1 那么将新节点的 next 指针指向原链表第一个结点
            newNode->next = *list;
            // 2.2.1.2 然后将新节点作为链表的第一个结点，即将让头指针指向新节点
            *list = newNode;
        }
        // 2.2.2 如果插入位置不是第一个，则找到第 i-1 个节点，将新节点插入到它的后面
        else {
            // 2.2.2.1 找到第 i 个节点的前驱节点
            LNode *iPreNode = *list;// 表示第一个节点
            LNode *node = (*list)->next;// 从第二个节点开始
            int count = 2;// 计数器，记录找到第几个节点了。注意，是从 2 开始的，因为第一个节点已经处理了
            while (count < i) {
                count++;
                iPreNode = node;
                node = node->next;
            }
            // 2.2.2.2 将新节点插入到 iPreNode 节点的后面
            newNode->next = iPreNode->next;
            iPreNode->next = newNode;
        }
    }
}

int main() {
    // 创建带头结点的单链表
    LNode *A;
    initWithHead(&A);// 初始化带头结点的单链表
    printWithHead(A);
    insertWithHead(&A, 1, 11);
    printWithHead(A);
    insertWithHead(&A, 1, 22);
    printWithHead(A);
    insertWithHead(&A, 2, 33);
    printWithHead(A);
    insertWithHead(&A, 2, 44);
    printWithHead(A);

    printf("\n");

    // 创建不带头结点的单链表
    LNode *B;
    initWithoutHead(&B);// 初始化不带头结点的单链表
    printWithoutHead(B);
    insertWithoutHead(&B, 1, 111);
    printWithoutHead(B);
    insertWithoutHead(&B, 1, 222);
    printWithoutHead(B);
    insertWithoutHead(&B, 2, 333);
    printWithoutHead(B);
    insertWithoutHead(&B, 2, 444);
    printWithoutHead(B);
}

执行结果如下：

[]
[11]
[22, 11]
[22, 33, 11]
[22, 44, 33, 11]

[]
[111]
[222, 111]
[222, 333, 111]
[222, 444, 333, 111]
二木成林
关注
  • 4
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表——笔记理解
Peyriat的博客
11-14 1027
众所周知，在一个数组中插入或是删除一个元素，都会需要移动后面所有的元素，导致代码的运行效率极低 但是！链表就可以很好的解决这一问题 就这么想吧，链表是一辆火车，链表的表头就是火车头，链表的每一个元素就是火车的一节节车厢，车厢里装的东西就是元素的数据域，每个车厢之间的卡子就是元素的指针 不会吧？不会有人没有见过火车吧？不会吧不会吧？ 总之，链表就是元素之间前后依赖，串联而成的 啊，对。链表的元素是不能随机访问的，就像你要从一个车厢到远处的另一个车厢，当然不是跨越一道任意门走过去，你没有这东西，所以，
C语言实现链表与文件的存取
柠檬i的博客
10-04 2万+
本程序主要功能是建立链表，然后把链表数据存储到文件中，然后把文件数据存储到数组中并输出
文件与链表的结合
白菜
06-21 4772
#include<stdio.h> #include<stdlib.h> /*题目： 建立一个链表，每个结点包括：学号、姓名、性别、年龄。输入一个 年龄，如果链表中的结点所包含的年龄等于此年龄，则将此结点删去。 */ typedef struct Student //定义结构体 { int num; char name...
单链表（带头结点）的存储结构与基本操作（c语言）------亲测可用
大学僧成长纪的博客
12-18 1万+
实现功能：单链表（带头结点）结点结构体的定义，单链表（带头结点）初始化、求元素个数、插入元素、删除元素、取元素、打印所有元素、就地逆置、撤销的操作。
链表的定义以及结构体，指针相关小结
Fitz的博客
03-30 8744
严蔚敏版的数据结构里面关于单链表的存储结构定义如下 typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; 《数据结构与算法分析》中关于单链表的存储结构定义如下 struct Node; typedef struct Node *PtrToNode; typedef PtrToNod
数据结构C语言版-线性表的单链表存储结构表示和实现.doc
07-13
本文档介绍了线性表的单链表存储结构表示和实现，使用C语言编写，提供了多种操作函数，包括初始化、销毁、清空、判断空表、获取元素、获取元素位序等。 数据结构是计算机科学中的一门重要学科，研究的是如何组织和...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码...
线性表的课件文档
01-03
§2.1 线性表的定义和抽象数据类型 §2.2 线性表的顺序存储和操作实现 §2.3 线性表的应用举例 §2.4 线性表的链接存储 §2.5 线性表在单链表上的实现
数据结构 线性表算法例题讲解.docx
02-08
配书：数据结构C语言版 清华大学出版社，严蔚敏编写 本文详细讲解了五个算法，核心思想还专门画了图，更有利于理解。 另外，文档中还有一两个我暂未解决的疑问，如果有想法的旁友评论区回复嗷。
线性表实验报告.doc
03-11
掌握线性表的链式存储结构——单链表的定义及其C语言实现。 掌握线性表在顺序存储结构即顺序表中的各种基本操作。 掌握线性表在链式存储结构——单链表中的各种基本操作。 6、认真阅读和掌握实验的程序。 7、上机...
【数据结构】节点和结点，到底怎么区分？
qq_42270373的博客
11-06 5万+
你们有没有纠结过这样一个问题，就是数据结构链表中结点的“结”到底是哪个字？ 说实话，在写这篇博客之前，我一直以为链表中的结点叫“节点”，，所以不管是给代码写注释，还是理解方面，我都觉得是“节点”，今天就来说一下节点和结点到底有什么不同？ 节点呢，被认为是一个实体，有处理能力，比如，网络上的一台计算机；而结点则只是一个交叉点，像“结绳记事”，打个结，做个标记，仅此而已，还有就是，要记住：一般算法...
【数据结构】线性表（二）—— 单链表（C语言版）
haoweixl的博客
05-16 2527
// 链表：单向链表、 循环链表、 双向链表 // 头结点为 存取数据元素 的情况 #include <stdio.h> #include <stdlib.h> #include <time.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define......
线性表-单链表
m0_46523041的博客
07-30 259
单链表
顺序表与链表
qq_45942662的博客
08-14 452
定义与特点 线性表定义：由0个或多个数据元素组成的有限序列。 顺序表：线性表的顺序存储结构。优点是查找，缺点是插入与删除。–优化–>单链表：优点：插入删除，缺点：查找（须从头到尾）–优化–>循环链表和双链表（还有双向循环）。 数组是从0开始而线性表是从1开始。 顺序表基操 顺序存储结构是把逻辑上相邻的节点存储在物理位置上相邻的存储单元中，结点之间的逻辑关系从物理上存储位置相邻得到体现。顺序存储结构的主要优点是节省存储空间，因为数据结点之间的逻辑关系没有占用额外的存储空间。另一个优点是可实现对结点
单链表的头增头删尾增尾删
单链表的头增头删尾增尾删
09-18 709
一、单链表的基本介绍 链表是一种数据结构，和数组同级，链表在进行循环遍历时效率不高，但是在插入和删除时优势明显。 单向链表是一种线性表，是有有结点（Node）组成的，逻辑上是线性的，物理存储上不一定，每个结点只能也只有知道下一个结点的存储位置，向外暴露的只有一个头结点（head），对链表的所有操作都是直接或者间接地通过头结点来实现的。 结点有两部分组成：value，next 单链表分为两种...
c语言链表数据存入文件和读取文件
热门推荐
c_manito的博客
05-07 8万+
c语言，链表数据存入文件和读取文件
深度理解单链表
m0_65334415的博客
04-10 1767
以自行车的链条来比喻我们的单链表，或者双链表 单链表是线性表的一种，因为从逻辑上来看单链表是一条线节点由指针域和数据域组成，所以一个节点含有两个不同类型的元素，那么我们学过的知识中，那种数据类型可以 保存不同类型的元素呢，那就是结构体，所以我们可以用结构体来定义一个节点 struct node { int id;//数据域，节点要保存的数据 struct node*next://指针成员，用于指向下一节点 }; 单链表只要知道一个节点，那么就可以知道之后的任意节点位置，直接通过...
单链表的按序号查找结点和按位查找结点
m0_51769031的博客
05-20 3570
1、按序号查找结点，从单链表的第一个结点出发，直到找到第i个结点，否则返回最后一个结点指针域NULL； LinkList GetElem(LinkList L,int i) { int j=1; if(i==0) //如果i==0，则返回头结点 return L; if(i<1) //i给的值无效 { return NULL; } LinkList p=L->next; //第一个结点指针赋给p while(p&&j<i) {
火影推荐程序连载72- 线性表的存储结构
li123128的博客
11-18 145
今天开始线性表部分的梳理，线性表主要分为了基础概念和基本操作两大部分，由于某些过程或概念比较抽象，我添加了部分图示，希望能够把这些抽象的东西直观的表达出来。 基本操作模块重点主要在单链表和顺序表两部分，本文着重梳理了线性表插入、删除、查询等基础方法并搭配了部分实例供参考。 1 基本概念 对于线性表来说，它是一组相同元素的有限序列，元素的个数就是线性表的长度，当元素个数为 0 时，线性表就是空表。 数据结构包括逻辑结构、存储结构和算法。线性表的基本概念这里主要看线性表的逻辑结构和存...
线性表和单链表有什么区别
最新发布
08-10
线性表和单链表是两种常见的数据结构。 线性表是一种线性的数据结构，元素从头到尾依次存储，每个元素在内存中占据固定的位置。查询某个元素的时间复杂度是O(1)，但是当需要插入或删除某个元素时，因为需要移动其他...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值