【数据结构】C语言实现单链表

已于 2023-07-29 20:32:16 修改
阅读量73 收藏
点赞数
文章标签： 数据结构 c语言 链表
于 2023-07-29 20:31:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44104992/article/details/131999548
版权

一、什么是单链表

  1. 单链表的节点分为两个部分，一部分存储数据、另一部分存储下一节点的指针，最后一个节点没有下一节点，则指向 NULL

    在这里插入图片描述

  2. 单链表分为带头结点和不带头结点

    • 带头结点：对与一些基本操作，可以很方便的实现

    • 不带头结点：对于一些基本操作，实现起来会比带头结点的复杂

    在这里插入图片描述

  3. 单链表的优缺点：

    • 优点：
      1. 不需要存储在连续的内存中
      2. 单链表的修改很方便
    • 缺点：
      1. 不能直接访问对应节点，需要依次往后访问
      2. 每个节点都需要浪费空间存放下一节点的指针

二、基本操作

0. 定义

  • data 用于存储数据，next 用于存储下一节点的指针
  • 将结构体重命名为 LinkNode 和 *LinkList
    • LinkNode 用于表示节点
    • *LinkList 用于表示链表
// 定义
typedef struct Node
{
    int data;
    struct Node* next;
} LinkNode, *LinkList;

1. 初始化链表

  • 不带头结点的单链表初始化只需要将链表设置为空即可
LinkList InitList()
{
    LinkList list = NULL;
    return list;
}

2. 销毁链表

  • 因为需要将 list 的修改后值带回，所以要用 LinkList* 类型，而LinkList 类型无法将修改后的值带回，就像下面两张图一样：

    • 使用 LinkList 类型 list 虽然指向的地址相同，名字也相同，但却是两个不同的变量（就好比有两个人他们都叫小明，他们都是同一个学校的，但是他们的身份证号是不同的。这里的小明就是变量名，同一个学校就是 list 都指向同一个位置，身份证号就是两个 list 在内存中的位置）
    • 使用 LinkList* 类型，可以通过解引用（*list）修改 list 的值

    在这里插入图片描述
    在这里插入图片描述

  • next 的类型为什么是 LinkNode* 而不是 LinkList ?

    • LinkNode* 与 LinkList 所表达的含义是一样的，并没有任何本质区别，但是 LinkNode* 更多的是要表达指向节点的指针，LinkList 则是表示指向链表的指针
    • 虽然说两者没有本质的区别，但还是建议根据含义的不同，使用不同的类型，这可以提高代码的可读性
status DestroyList(LinkList* list)
{
    while((*list) != NULL)	// 当 *list 等于 NULL 时，表示链表为空
    {
        LinkNode* next = (*list)->next;
        free(*list);		// 释放当前节点
        (*list) = next;		// *list 指向下一节点
    }

    (*list) = NULL;			// 将 *list 指向 NULL，防止野指针
    return SUCCESS;
}

3. 头插法插入

  • malloc 函数当空间不足时，会返回 NULL, node = NULL 时，就不应该继续往后执行

  • 修改next 指针时，要注意修改指针的顺序，先将 node 指向 list ，再修改 list

    在这里插入图片描述

status HeadInsertList(LinkList* list, int e)
{
    LinkNode* node = (LinkNode*)malloc(sizeof(LinkNode));
    if(node == NULL)
    {
        return FAILURE;
    }
    node->next = (*list);
    node->data = e;
    (*list) = node;
    return SUCCESS;
}

4. 尾插法插入

  • 定位到单链表的末尾，再将末尾的 next 指向新的节点

在这里插入图片描述

status TailInsertList(LinkList list, int e)
{
    LinkNode* node = (LinkNode*)malloc(sizeof(LinkNode));
    if(node == NULL)
        return FAILURE;

    while(list->next != NULL)
        list = list->next;

    node->data = e;
    node->next = NULL;
    list->next = node;
    
    return SUCCESS;
}

5. 头删法删除

  • 删除第一个元素时，会修改 list 所以要传入 LinkList * 类型的参数
  • 先将 list 指向第二个节点，再将第一个节点释放

在这里插入图片描述

status HeadDeleteList(LinkList* list)
{
    LinkNode* node = (*list);
    (*list) = (*list)->next;
    free(node);

    return SUCCESS;
}

6. 尾删法删除

  • cur 用于遍历整个单链表，查找最后一个节点，pre 用于存放 cur 指向节点的前一个节点

  • 当 cur 指向最后一个节点时，释放 cur，并将 pre 指向节点的 next 设置为 NULL

  • 当单链表中只有一个节点时，使用尾删法会修改 list 的值，所以参数应该为 LinkList* 类型

    在这里插入图片描述

status TailDeleteList(LinkList* list)
{
    LinkNode* cur = (*list);
    LinkNode* pre = NULL;
    while(cur->next != NULL)
    {
        pre = cur;
        cur = cur->next;
    }

    if((*list) == cur)
        (*list) = NULL;
    else
        pre->next = NULL;

    free(cur);

    return SUCCESS;
}

7. 按位插入

  • 当要在第一位插入时，需要进行特殊处理，可以直接使用头插法进行插入

  • 需要再其他位值插入时，只需要找到要插入位置的前一位，将新节点的 next 指向当前位置的下一节点，再将当前节点的 next 指向新节点
    在这里插入图片描述

status InsertList(LinkList* list, int pos, int e)
{
    if(pos == 1)
    {
        return HeadInsertList(list, e);
    }
    
    int count = 1;
    LinkNode* cur = (*list);
    LinkNode* node = (LinkNode*)malloc(sizeof(LinkNode));
    if(node == NULL)
        return FAILURE;
    while(count < pos - 1 && cur != NULL)
    {
        cur = cur->next;
        count++;
    }

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

    node->data = e;
    node->next = cur->next;
    cur->next = node;
    return SUCCESS;
}

8. 按位删除

  • 先将 cur 移动到要删除的节点，将pre->next 指向 cur->next，最后释放掉 cur 指向的节点
    在这里插入图片描述
status DeleteList(LinkList* list, int pos)
{
    if(pos == 1)
        return HeadDeleteList(list);
    
    int count = 1;
    LinkNode* cur = (*list);
    LinkNode* pre = NULL;
    while(count < pos && cur != NULL)
    {
        pre = cur;
        cur = cur->next;
        count++;
    }

    if(cur == NULL)
        return FAILURE;
    
    pre->next = cur->next;
    free(cur);
    
    return SUCCESS;
}

9. 打印链表

  • 循环打印每一个节点，当 list 等于 NULL 时，表示以及遍历了整个链表
status PrintList(LinkList list)
{
    while(list != NULL)
    {
        printf("%d -> ", list->data);
        list = list->next;
    }
    printf("NULL\n");
    return SUCCESS;
}

10. 按位查找

LinkNode* GetNode(LinkList list, int pos)
{
    int count = 1;
    while(count < pos && list != NULL)
    {
        list = list->next;
        count++;
    }

    return list;
}

11. 按值查找

LinkNode* LocateElem(LinkList list, int e)
{
    while (list != NULL)
    {
        if(list->data == e)
            return list;
        list = list->next;
    }

    return list;
}

12. 求表长

int Length(LinkList list)
{
    if(list == NULL)
        return 0;

    int count = 1;
    while (list)
    {
        list = list->next;
        count++;
    }
    
    return count;
}

三、完整代码

  • LinkedList.h

    #pragma once

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

#define FAILURE 0
#define SUCCESS 1
typedef int status;

// 定义
typedef struct Node
{
    int data;
    struct Node* next;
} LinkNode, *LinkList;

// 1. 初始化链表
LinkList InitList();

// 2. 销毁链表
status DestroyList(LinkList* list);

// 3. 头插法插入
status HeadInsertList(LinkList* list, int e);

// 4. 尾插法插入
status TailInsertList(LinkList list, int e);

// 5. 头删法删除
status HeadDeleteList(LinkList* list);

// 6. 尾删法删除
status TailDeleteList(LinkList* list);

// 7. 按位插入 
status InsertList(LinkList* list, int pos, int e);

// 8. 按位删除
status DeleteList(LinkList* list, int pos);

// 9. 打印链表
status PrintList(LinkList list);

// 10. 按位查找
LinkNode* GetNode(LinkList list, int pos);

// 11. 按值查找
LinkNode* LocateElem(LinkList list, int e);

// 12. 求表长
int Length(LinkList list);

  • LinkedList.c

    #include "./head/LinkedList.h"

// 1. 初始化链表
LinkList InitList()
{
    LinkList list = NULL;
    return list;
}

// 2. 销毁链表
status DestroyList(LinkList* list)
{
    while((*list) != NULL)
    {
        LinkNode* next = (*list)->next;
        free(*list);
        (*list) = next;
    }

    (*list) = NULL;
    return SUCCESS;
}

// 3. 头插法插入
status HeadInsertList(LinkList* list, int e)
{
    LinkNode* node = (LinkNode*)malloc(sizeof(LinkNode));
    if(node == NULL)
    {
        return FAILURE;
    }
    node->next = (*list);
    node->data = e;
    (*list) = node;
    return SUCCESS;
}

// 4. 尾插法插入
status TailInsertList(LinkList list, int e)
{
    LinkNode* node = (LinkNode*)malloc(sizeof(LinkNode));
    if(node == NULL)
        return FAILURE;

    while(list->next != NULL)
        list = list->next;

    node->data = e;
    node->next = NULL;
    list->next = node;
    
    return SUCCESS;
}


// 5. 头删法删除
status HeadDeleteList(LinkList* list)
{
    LinkNode* node = (*list);
    (*list) = (*list)->next;
    free(node);

    return SUCCESS;
}

// 6. 尾删法删除
status TailDeleteList(LinkList* list)
{
    LinkNode* cur = (*list);
    LinkNode* pre = NULL;
    while(cur->next != NULL)
    {
        pre = cur;
        cur = cur->next;
    }

    if((*list) == cur)
        (*list) = NULL;
    else
        pre->next = NULL;

    free(cur);

    return SUCCESS;
}

// 7. 按位插入 
status InsertList(LinkList* list, int pos, int e)
{
    if(pos == 1)
    {
        return HeadInsertList(list, e);
    }
    
    int count = 1;
    LinkNode* cur = (*list);
    LinkNode* node = (LinkNode*)malloc(sizeof(LinkNode));
    if(node == NULL)
        return FAILURE;
    while(count < pos - 1 && cur != NULL)
    {
        cur = cur->next;
        count++;
    }

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

    node->data = e;
    node->next = cur->next;
    cur->next = node;
    return SUCCESS;
}

// 8. 按位删除
status DeleteList(LinkList* list, int pos)
{
    if(pos == 1)
        return HeadDeleteList(list);
    
    int count = 1;
    LinkNode* cur = (*list);
    LinkNode* pre = NULL;
    while(count < pos && cur != NULL)
    {
        pre = cur;
        cur = cur->next;
        count++;
    }

    if(cur == NULL)
        return FAILURE;
    
    pre->next = cur->next;
    free(cur);

    return SUCCESS;
}

// 9. 打印链表
status PrintList(LinkList list)
{
    while(list != NULL)
    {
        printf("%d -> ", list->data);
        list = list->next;
    }
    printf("NULL\n");
    return SUCCESS;
}

// 10. 按位查找
LinkNode* GetNode(LinkList list, int pos)
{
    int count = 1;
    while(count < pos && list != NULL)
    {
        list = list->next;
        count++;
    }

    return list;
}


// 11. 按值查找
LinkNode* LocateElem(LinkList list, int e)
{
    while (list != NULL)
    {
        if(list->data == e)
            return list;
        list = list->next;
    }

    return list;
}

// 求表长
int Length(LinkList list)
{
    if(list == NULL)
        return 0;

    int count = 1;
    while (list)
    {
        list = list->next;
        count++;
    }
    
    return count;
}
r1v0z
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构-C语言实现单链表-数据结构学习
05-26
C语言实现的数据结构中的单链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对链表边界的判定 实现了以下功能： 创建单链表 向顺序表中插入元素(头插法，尾插...
数据结构C语言-单链表操作实验
04-23
数据结构C语言版，单链表操作的菜单式实验，包括单链表的初始化、创建、求表长、插入删除元素、销毁和清空单链表等操作，具体操作根据屏幕提示进行。
【数据结构】C语言实现单链表的基本操作
蒙奇D索大的博客
12-28 1547
【数据结构】第二章——线性表(6) 详细介绍了通过C语言实现单链表的基本操作……
C语言实现单链表
m0_70885714的博客
10-19 5602
单链表的基本操作 单链表的基本操作包括单链表的初始化、建立、插入、查找、修改、打印、表长的输出等等运算。其中比较重要的是按值查找元素、查找某位置并插入元素、修改某位置的元素以及尾插法建表。目前该表是只实现了这些操作，并进行的测试。
c语言实现单链表(数据结构)
m0_62143067的博客
04-25 2437
目录 实现单链表的基本操作 想要把链表研究透彻 就需要对指针的深入了解 先引入一个概念 什么是指针？什么是变量？什么是指针变量？ 我们创建的 int char double 都属于变量 变量有地址 指向这个地址就能改变这个变量 我们创建的指针也是变量 那指针变量也有自己的地址 指向这个地址就能改变这个变量 这个问题非常抽象 改变变量 就需要创建一个指针指向这个变量的地址 如果我们想要改变指针变量(注意这时就应该是指针变量)就要创建一个指针指向指针变量的地址 才能改变这个...
数据结构（初阶）—— C语言实现单链表
M的博客
04-02 1767
数据结构（初阶）——C语言实现单链表
数据结构 C语言 实现单链表的各种基本操作
WindsProgrammer的博客
06-01 5516
大概写了150多行，都是很基础的操作。需要的自取。 （书籍为数据结构教程（第五版）李春葆） 实验内容 实验三 链表基本操作的实现 【实验目的】 1．掌握线性表的链式存储表示。 2．掌握单链表的基本操作，包括创建、查找、插入和删除等算法。 【实验内容】 编写程序linklist.cpp，实现单链表的各种基本运算（假设单链表的元素类型为char），并在此基础上设计主程序main.cpp，完成如下功能： 1．初始化单链表； 2．依次采用尾插法插入元素a，b，c，d，e； 3．输出单链表； 4．判断单链表的长度；
数据结构c语言代码实现单链表
小洁洁
01-03 386
今天让我们一起来看看如何用c语言实现单链表尼？废话不多说，直接上代码。这是分装的代码，直接合并即是全部代码。主要内容如下：声明头文件，结构体。 随便一位置删除元素。初始化链表。头插法添加。尾插法添加 ，打印链表
＜数据结构＞ C语言实现 单链表
shinamashiro_的博客
04-17 2041
1.链表的概念及结构 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序时通过链表中的指针链接次序实现的。 从上图可以看出： 1.链式结构在逻辑上时连续的，但在物理上不一定连续 2.显示中的节点一般都是从堆上申请出来的 3.从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续 2.实现单链表 2.1 SList.h #pragma once #include <stdio.h> #include <string.
数据结构——单链表（C语言实现）
weixin_57154303的博客
08-23 3838
单链表的基本操作有 初始化，头插，尾插，按位置插，头删，尾删，按位置删，查找，按值删，获取有效值个数，判空，清空，销毁，打印 - 单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点的构成：==元素(数据元素的映象)== + ==指针(指示后继元素存储位置)==，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。
【数据结构】C语言实现单链表基本操作
weixin_43716338的博客
02-05 3044
#include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; //单链表的存储结构 typedef struct LNode { ElemType data; struct LNode *next; //next指向自身类型struct LNode *的指
数据结构 C语言实现循环单链表的实例
08-30
数据结构 C语言实现循环单链表的实例 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、表示和操作的方法。在计算机科学中，数据结构是指数据的组织、存储和操作的方法。循环单链表是一种常见的数据...
c语言实现单链表算法示例分享
09-04
单链表是一种基础的数据结构，在计算机科学中广泛应用。下面将详细介绍c语言实现单链表算法的示例。 1. 单链表的定义 单链表是一种链式数据结构，其中每个节点由数据域和指针域组成。数据域存储当前节点的数据，...
C语言实现单链表（常规操作）
06-19
C语言实现单链表（常规操作） LinkList CreateHeadListH(); // 头插法创建单链表 LinkList CreateHeadListT(); // 尾插法创建单链表 int ListEmpty(); // 单链表判空 int ListLength(); // 求单链表长度...
数据结构—链式二叉树-C语言
h_number_1的博客
07-11 1072
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
堆、栈和队列（数据结构）
weixin_50956409的博客
07-10 1140
堆：用于实现优先队列和动态数据结构，操作复杂，适用于需要优先级排序的场景。队列：用于实现先进先出（FIFO）的数据结构，操作简单，适用于需要顺序处理的场景。栈：用于实现后进先出（LIFO）的数据结构，操作简单，适用于需要后入先出的场景。每种数据结构都有其特定的应用场景和优势。在实际编程中，选择合适的数据结构可以大大提高程序的效率和性能。堆上的内存需要程序员手动管理，容易发生内存泄漏。为了避免内存泄漏，程序员应该在不再需要动态分配的内存时，使用free()函数将其释放。
数据结构专项-字符串
最新发布
qq_52241267的博客
07-16 354
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。深拷贝和浅拷贝：浅拷贝实际上是复制了被拷贝对象的引用，也就是说浅拷贝的和被拷贝对象指向的是同一块内存空间，而深拷贝则是连同引用的对象也被拷贝，两者指向的是不同的内存空间。然后计算乘法，故之后是*，再计算加法，因此+要在6的前面，不然就是计算4*(x+3)+6了，故选D。中缀表达式中应该先计算x+3，因此后缀表达式中+应该出现在x和3的后面，排除BC。
数据结构第26节 广度优先搜索
hummhumm的专栏
07-14 928
首先，我们需要定义迷宫的结构。我们可以用一个二维数组来表示迷宫，其中0代表可通行的空地，1代表墙。为了存储迷宫中的每个位置状态，我们需要创建一个节点类，包含位置坐标和从起点到该位置的距离。int x;int y;this.x = x;this.y = y;
数据结构c语言版单链表
05-26
以下是C语言实现的单链表数据结构： ```c #include #include // 定义链表节点 typedef struct Node { int data; struct Node* next; } Node; // 初始化链表 Node* initList() { Node* head = (Node*)malloc...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值