链表的介绍、实现（C语言）及应用

最新推荐文章于 2024-08-06 06:00:00 发布
最新推荐文章于 2024-08-06 06:00:00 发布
阅读量879 收藏 5
点赞数
分类专栏： 数据结构与算法 专题 文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42642142/article/details/120331909
版权

链表

注：会持续更新

首先我们先来看看链表的几个特点：离散的内存分布、快速插入/删除

最直观的就是将其和线性数据结构列表对比：

在这里插入图片描述

可见，链表的内存分布是离散的，想要知道其中一个目标结点的地址，首先要知道其前驱结点，根据前驱结点的指针来找到目标结点。

至于快速插入和删除的特点，先别急，我们先看下链表的分类。

常见种类：单向链表、双向链表、循环链表、双向循环链表

单向链表：

在这里插入图片描述

单链表即只能朝着一个方向去遍历，根据结点的next指针来找到目标结点，尾结点指向空指针NULL

双向链表：[java中的 LinkedHashMap就用的这个容器]

在这里插入图片描述

双向链表即只能朝着前后个方向去遍历，要想找到目标结点，需要先找到其前驱结点或后继结点根据next或pre指针找到目标结点，尾结点的next指向空指针，pre指针指向前一个结点。

循环链表：

在这里插入图片描述

循环链表就是尾结点的后继指针指向的是头节点，这样从链尾到链头就很方便。很适合解决“问题中带有循环提示的问题”

双向循环链表：

到这里，就算不给你双向链表的结构图你应该也能猜到了，是的，就是向双向链表一样每个结点加上前驱指针，头结点的前驱指针指向了最后的尾结点。

常见应用场景：

  • LRU缓存淘汰算法
  • CPU缓存、数据库缓存、浏览器缓存

为什么要有缓存淘汰算法？

因为缓存的大小有限，当缓存被用满时，应该决定哪些数据被清理出去，哪些应该被保留。

常见的有三种：

  • 先进先出策略FIFO First in First out
  • 最少使用策略LFU Least Frequently Used
  • 最近最少使用策略LRU Least Recently Used

如何采用链表实现LRU：

  • 维护一个有序单链表，越靠近链表尾部的结点是越早之前[即长时间没有访问了]访问的结点。
  • 当有数据被访问时，从链表头开始顺序遍历链表。
    • 如果此数据已经被缓存在链表中了，则将其从链表中删除，然后插入至链表头部。
    • 如果没有在缓存链表中。
      • 如果缓存未满，直接插入链表头部。
      • 如果缓存已经满了，则先删除尾结点，再将数据插入链表头部。

链表Vs数组

在这里插入图片描述

数组使用的是连续的内存空间，可以借助CPU缓存机制，预读数组中的数据，访问效率高；链表不是连续存储的，不能够直接访问，必须进行遍历才能找到目标结点，因此访问效率低。

这里的CPU缓存机制指的是什么？？

  • CPU在从内存读取数据的时候，会先把读取到的数据加载到CPU的缓存中。而CPU每次从内存读取数据并不是只读取那个特定要访问的地址，而是读取一个数据块并保存到CPU缓存中，然后下次访问内存数据的时候就会先从CPU缓存开始查找，如果找到就不需要再从内存中取。这样就实现了比内存访问速度更快的机制。因为数组存储空间是连续的，所以在加载的时候可以把以后的几个下标元素同时加载到CPU缓存，这样执行速度会快于存储空间不连续的链表存储。这就是所谓的“局部性原理”

数组的缺点是大小固定，如果你想要申请的内存过大，可能系统没有那么大的连续内存空间给你，那么就会报错。同时，当你申请的数组不够用了，需要重新申请一个新的更大的数组，此时就需要将原本的数据全部拷贝过去，显然就很浪费时间和效率。

同时，你可能也注意到了，链表每个结点不仅需要保存值，还要有一个指针来指向后继结点，这样链表存储信息的利用率可能就没有数组那么高[因为需要分出一部分内存存储指针]。因此，如果在对内存要求很苛刻的情况下，最好选择数组。

链表操作的注意事项：

  • 警惕指针丢失和内存泄露。

    比如在插入结点时候一定要先将待插入结点指针指向被插入结点的下一个结点，然后修改被插入结点next指向待插入结点，防止指针丢失

  • 留意特殊情况。

    • 链表为空，程序能否正常工作？

      通常就是特殊判断

    • 链表只包含一个结点或两个结点，程序有没有Bug？

    • 处理头结点和尾结点时，程序能够正常工作？

      通常加入哨兵结点或者if条件判断解决

  • 利用画图来辅助自己。

相关代码实现：
包含了单向链表、双向链表、循环链表的C语言实现代码：
link.h

#ifndef LINK_H_
#define LINK_H_
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<math.h>
#include<string.h>

typedef char elemtype;

#define ERROR 0
#define OK    1

//单向链表//
typedef struct Node{
    elemtype data;
    struct Node * next;
}SNode,*SLinklist;
//单链表函数//
bool Init_SLinkList(SLinklist *L);
bool Creat_SLinkList_Tail(SLinklist *L);
bool Creat_SLinkList_Head(SLinklist *L);
SNode *Find_SLinkNode_Pos(SLinklist L,int i);
SNode *Find_SLinkNode_Val(SLinklist L,elemtype key);
int Get_SLink_Len(SLinklist L);
void Print_SLink(SLinklist L);
void Print_Node(SNode *node);
int InsertSLinkList(SLinklist *L,int n,elemtype data);
int Delete_DatainList(SLinklist *L,int n);
//*********//

//双向链表//
typedef struct DNode{
    elemtype data;
    struct DNode * pre;
    struct DNode * next;
}DNode,*DLinklist;
//双向链表函数//
bool Init_DLinklist(DLinklist *L);
bool Creat_DLinklist_Tail(DLinklist *L);
bool Print_DLinkist(DLinklist L);
//********//

//单向循环链表//
typedef struct SCNode{
    elemtype data;
    struct SCNode * next;
}SCNode,*SCLinklist;
//单向循环链表函数//
bool Init_SCLinklist(SCLinklist *L);
bool Creat_SCLinklist_Tail(SCLinklist *L);
bool Print_SCLinkist(SCLinklist L);
//********//
#endif

link.c

//单向链表//

//初始化单链表
bool Init_SLinkList(SLinklist *L)
{
    (*L) = (SLinklist)malloc(sizeof(SNode));
    if(!(*L))
    {
        printf("malloc error!");
        return ERROR;
    }
    (*L)->next =NULL;
    return OK;
}
//尾插法建立单链表
bool Creat_SLinkList_Tail(SLinklist *L)
{
    elemtype e;
    SLinklist Node_L,Node_new;
    Node_L = (*L);
    printf("Input data... :");
    scanf("%c",&e);
    while ('#' != e)
    {
        Node_new = (SLinklist)malloc(sizeof(SNode));
        if(!Node_new)
        {
            printf("malloc error!");
            return ERROR;
        }
        Node_new->data = e;
        Node_new->next = Node_L->next;
        Node_L->next = Node_new;
        Node_L = Node_new;
        scanf("%c",&e);
    }
    getchar();
    return OK;
}

//头插发建立单链表
bool Creat_SLinkList_Head(SLinklist *L)
{
    elemtype e;
    SLinklist Node_L,Node_new;
    Node_L = (*L);
    printf("Input data... :");
    scanf("%c",&e);
    while ('#' != e)
    {
        Node_new = (SLinklist)malloc(sizeof(SNode));
        if(!Node_new)
        {
            printf("malloc error!");
            return ERROR;
        }
        Node_new->data = e;
        Node_new->next = Node_L->next;
        Node_L->next = Node_new;
        scanf("%c",&e);
    }
    getchar();
    return OK;
}
//查找单链表中第i个结点,按照位置查找
SNode *Find_SLinkNode_Pos(SLinklist L,int i)
{
    int count=0;
    SLinklist Node_find;
    Node_find = L;
    while(Node_find != NULL)
    {
        Node_find = Node_find->next;
        count ++;
        if(count == i)
        {
            return Node_find;
        }
    }
    printf("What you put n is error!\r\n");
    return NULL;
}

//按照值查找单链表
SNode *Find_SLinkNode_Val(SLinklist L,elemtype key)
{   
    SLinklist Node_find;
    Node_find = L;
    while (Node_find != NULL)
    {
        Node_find = Node_find->next;
        if (Node_find->data == key)
        {
            return Node_find;
        }
    }
    printf("No find what you want node!\r\n");
    return NULL;

}
//计算单链表长度
int Get_SLink_Len(SLinklist L)
{
    int len=0;
    SLinklist Node_L;
    Node_L = L->next;
    while (Node_L != NULL)
    {
        len++;
        Node_L=Node_L->next;

    }
    printf("The Link's len is %d\r\n",len);
    return len;
}

//打印单链表//
void Print_SLink(SLinklist L)
{
    SLinklist Node_L;
    Node_L = L->next;
    while (Node_L)
    {
        printf("%c ",Node_L->data);
        Node_L = Node_L->next;
    }
    printf("\r\n");
}

void Print_Node(SNode *node)
{
    printf("The Node data is %c\r\n",node->data);
}
//向单链表中第n个结点前（第n-1个结点后)插入一个结点//
int InsertSLinkList(SLinklist *L,int n,elemtype data)
{
    int i,j;
    SLinklist node_L,node_new;
    node_L=(*L)->next;   
    //找到第n-1个结点
    
    n=n-2;
    while(n)
    {
        if(node_L == NULL)
        {
            break;
        }
        node_L=node_L->next;
        n--;
    }
    if(n)
    {
        printf("Input 'n' is error!");
        return ERROR;
    }
    node_new=(SLinklist)malloc(sizeof(SNode));
    node_new->next=node_L->next;
    node_L->next=node_new;
    node_new->data=data;

    return OK;
}

//删除单链表中第n个元素//
int Delete_DatainList(SLinklist *L,int n)
{
    int i,j;
    SLinklist node_L,node_delete;
    node_L=(*L)->next;   
    //找到第n-1个结点
    
    n=n-2;
    while(n)
    {
        if(node_L == NULL)
        {
            break;
        }
        node_L=node_L->next;
        n--;
    }
    if(n)
    {
        printf("Input 'n' is error!");
        return ERROR;
    }    
    node_delete=node_L->next;
    node_L->next=node_delete->next;
    free(node_delete);

    return OK;
}


//双向链表//
bool Init_DLinklist(DLinklist *L)
{
    (*L) = (DLinklist)malloc(sizeof(DNode));
    if(!(*L))
    {
        printf("malloc error!\n");
        return ERROR;
    }
    (*L)->next = NULL;
    (*L)->pre = NULL;
    return OK;
}
bool Creat_DLinklist_Tail(DLinklist *L)
{
    elemtype e;
    DLinklist Node_L,Node_new;
    Node_L = (*L);
    printf("Input data... :");
    scanf("%c",&e);
    while ('#' != e)
    {
        Node_new = (DLinklist)malloc(sizeof(SNode));
        if(!Node_new)
        {
            printf("malloc error!");
            return ERROR;
        }
        Node_new->data = e;

        Node_new->next = Node_L->next;
        Node_new->pre = Node_L;
        Node_L->next = Node_new;
        Node_L = Node_new;
        scanf("%c",&e);
    }
    getchar();
    return OK;
}
//打印双向链表
bool Print_DLinkist(DLinklist L)
{
    DLinklist Node_L;
    Node_L = L->next;
    while (Node_L)
    {
        printf("%c ",Node_L->data);
        Node_L = Node_L->next;
    }
    printf("\r\n");
}

//单向循环链表//
bool Init_SCLinklist(SCLinklist *L)
{
    (*L) = (SCLinklist)malloc(sizeof(SCNode));
    if(!(*L))
    {
        printf("malloc error!");
        return ERROR;
    }
    (*L)->next =(*L);
    return OK;
}
//尾插法创建循环链表
bool Creat_SCLinklist_Tail(SCLinklist *L)
{
    elemtype e;
    SCLinklist Node_L,Node_new;
    Node_L = (*L);
    printf("Input data... :");
    scanf("%c",&e);
    while ('#' != e)
    {
        Node_new = (SCLinklist)malloc(sizeof(SCNode));
        if(!Node_new)
        {
            printf("malloc error!");
            return ERROR;
        }
        Node_new->data = e;

        Node_new->next = Node_L->next;
        Node_L->next = Node_new;
        Node_L = Node_new;
        scanf("%c",&e);
    }
    getchar();
    return OK;
}
//打印循环链表
bool Print_SCLinkist(SCLinklist L)
{
    SCLinklist Node_L;
    Node_L = L->next;
    while (Node_L != L)
    {
        printf("%c ",Node_L->data);
        Node_L = Node_L->next;
    }
    printf("\r\n");
}
Small_Fish25
关注
专栏目录
链表及其应用（C语言实现）
qq_38311609的博客
12-17 3965
  链表及其应用（C语言实现） 前言 顺序表由于是顺序存储的，所以其优点就是访问元素的效率及其高，但是对元素的删除插入操作效率却很低，因为为了保持其顺序存储的特性在插入删除的过程中可能需要大量的搬移元素。为了解决这个问题，人们设计了另一种数据结构----链表。 链表定义 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表...
C语言----链表及其应用
pearl333的专栏
09-16 835
本部分是C语言的最后一部分，因为教研室的一些工作，导致了我的进度滞后，在此对自己提出批评。   1、链表的定义：特点：按需分配存储单元，物理地址不连续           单向链表分为  队列 和 堆栈 2、链表的插入和删除； ==================================================================================
链表在C语言中的应用,C语言-链表及其相关应用
weixin_39612877的博客
05-19 976
C语言系列一.链表定义1).引1.什么是链表2.为什么要引入链表3.链表有什么用4.单向表(带头)优点2).链表涉及的基本概念1.头指针2.头节点；3.链表存在：4.链表空：5.链表尾：6.带头节点链表，无头节点链表7.单链表， 双链表，循环链表3).代码书写一个普通链表代码头插法尾插法二.链表的创建头插法尾插法三.链表操作1.创建2.输入3.输出4.查找5.修改6.插入，删除插入删除一.链表定义...
C语言菜鸟入门·数据结构·链表超详细解析
最新发布
时光の尘的博客
08-06 1535
对比于顺序表的每个节点只存放数据元素，单链表的每个节点除了存放数据元素外，还要存储指向下一个节点的指针。优点：可随机存储，存储密度较高；缺点：要求大片连续空间，改变容量不方便。优点：不要求大片连续空间，改变容量方便；缺点：不可随机存取，要耗费一定空间存放指针。对于单链表的每一个结点，都需要有一个数据域用于存放节点的数据元素，需要一个指针域用于指向下一个结点。而若是我们想要增加一个新的结点，我们可以使用malloc关键字，例如：首先，我们先声明一个指向。
C语言链表的重要性,C语言的链表特点
weixin_31762925的博客
05-21 1346
如何用C语言来处理链表呢，链表是一种常见的重要的数据结构它是动态的进行存储分配的一种结构，由前面的介绍我们已经知道了用数组存放数据的时候必须要事先定义固定的数组长度，如果有的速度比较大有了速度比较小，如果用同一个速度先后存放不同的数据则必须要定义长度，所以链表怎没有这种特点。知识点①：那么链表是一种常见的重要的数据结构，这也是C语言中的数据结构特点，链表中有一个头指针的变量它存放一个地址，这个地址...
c语言链表的综合应用
09-11
c语言初级的链表综合应用，适合于初学c语言的各位亲。
链表-使用C语言实现循环链表应用之解决约瑟夫问题.zip
03-13
本项目专注于使用C语言实现循环链表，并将其应用于解决著名的约瑟夫问题。 约瑟夫问题（Josephus Problem）源于一个古老的故事，它涉及到在圆形排列的人群中，按照一定的间隔（通常为3或4）剔除一个人，直到剩下...
链表-使用C语言实现循环链表.zip
03-13
本资源“链表-使用C语言实现循环链表.zip”将详细介绍如何用C语言来创建和操作循环链表。 首先，我们要理解循环链表的基本概念。循环链表是一种链表，其最后一个节点的指针不是NULL，而是指向链表的第一个节点，...
逆置数组实现和链表实现（C语言实现） 数组和链表.pdf
04-18
“逆置数组实现和链表实现（C语言实现）” 本资源主要讲解了数组和链表的逆置操作的C语言实现，包括数组逆置和链表逆置两部分。下面是对该资源的详细知识点解释： 一、数组逆置 数组逆置是将数组中的元素按照逆序...
C语言实现多种链表快速排序
05-08
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和程序设计中。快速排序是一种高效的排序算法，由英国计算机科学家C.A.R. Hoare在1960年提出，它的基本思想是通过一趟排序将待排记录分隔成独立的两...
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据结构。在非循环双向链表中，每个节点包含两个指针，分别指向它的前一个节点和后一个节点。...
数据结构专题实验1- 链表的应用（C语言实现）
qq_60545192的博客
01-30 842
软件工程专业本科，数据结构学期实训第一期，此系列旨在分享和讲解本人写过的项目代码，方便各位朋友们学习，以求共同进步。
数据结构之链表C语言实现以及使用场景分析
weixin_30482181的博客
07-09 588
牢骚：本篇博客两个星期前已经存为草稿，鉴于发生一些糟糕的事情，今天才基本完成。本人6月份应届毕业生一枚，毕业后当天来到帝都，之后也非常顺利，面试了俩家公司都成功了。一家做C++方面电商ERP，一家做wifi模块，觉得第二家公司小，薪资低，但是觉得好玩就去了。同时，在学校也喝了不少鸡汤，觉得公司小怎么了。然而去了不到20天，公司被深圳一家公司收购了，公司动员我去深圳，我尼玛我才来20多天啊，有木有？...
链表（Linked List）算法的使用场景和使用例子详解
一如既往的准备文章
03-05 2888
python复制代码。
c语言之链表
liyaoliy的博客
11-01 472
定义：链表是一种物理储存上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种现行储存结构。 特点： 链表由一系列节点（链表中每一个元素称为节点）组成，节点在运行时动态生成（malloc）,每个节点包括两个部分： （1）存储数据元素的数据域 （2）存储下一个节点地址的指针域 链表的构成：链表由一个个节点构成，每个节点一般采用结构体的形式组织，例如： typedef struct student { int num; char name[20]; struct student *next; //
【数据结构与算法】深入浅出：单链表的实现和应用
青竹雾色间.的博客
06-07 5475
在本篇博客中，我们将深入探索一种常见的数据结构——单链表。
「算法精解_C语言描述」链表_关于链表特点的几个问与答
idreamo的博客
11-15 252
一、链表与数组都有自己的优势，那什么情况下适合使用数组，什么情况下适合使用链表？ 当我们期望进行频繁的插入和删除操作时，链表比数组更有优势。然而，当我们期望进行随机访问的次数高于插入和删除操作的次数时，数组就显得更有优势了。随机访问是数组的强项，因为它们的元素在内存中是连续排列的。这种连续的排列，使用数组中的任何元素都能够在O(1)的时间内通过其索引访问。 ...
【知识分享】数据结构的应用——链表
知识噬元兽的博客
09-25 1836
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。由于在物理存储上可以以非连续状态存在，使得链表变得极其灵活。同时，链表就是C语言指针最完美的表现形式之一。常见的链表形式有两种，单向链表和双向链表。
C 语言中链表详解
晓林爱学习的博客
04-22 667
链表通过将数据元素存储在内存中的非连续区域上来实现，每个数据元素都包含指向下一个元素的指针，可以用来遍历整个链表。因此，要遍历链表，必须从链表的起始位置开始，然后一直迭代到链表的结尾位置。该函数接收一个指向指针的指针，指向链表头节点，以及要插入链表中的数据元素作为参数。然后，将指针指向该新节点的地址，并更新链表的头节点，使其指向新节点。在 C 语言中，链表的基本结构是一个包含数据元素和指向下一个元素的指针的单独结构体。在循环中，通过输出当前节点的数据和将当前指针移动到下一个节点来依次输出链表中的所有元素。
C语言链表实现数据存储及基本操作
"这篇资料主要介绍了如何利用链表解决数据存储问题，特别是在C语言环境下的应用。链表是一种高效的数据结构，适用于动态数据的存储，因为它允许在内存中灵活地添加、删除和修改元素。资料中提到的是单向链表，每个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值