链表知识总结

最新推荐文章于 2024-09-07 10:35:58 发布
最新推荐文章于 2024-09-07 10:35:58 发布
阅读量859 收藏
点赞数
文章标签： 链表 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/int____/article/details/130478783
版权
本文介绍了线性表的概念，包括线性关系和线性表的顺序存储（顺序表）与链式存储（链表）的比较。链表的结构包括单链表、双向链表和循环链表，以及哨兵节点的作用。此外，详细阐述了单链表的基本操作，如创建、长度计算、判断空表、查找、插入和删除等操作，还包括了链表的反转和循环链表的查找方法。
摘要由CSDN通过智能技术生成

文章目录

一、线性表的概念

线性关系

  1. 当1<i<n时，ai的直接前驱为ai-1, ai的直接后继为ai+1。
  2. 除了第一个元素与最后一个元素，序列中任何一个元素有且仅有一个直接前驱元素, 有且仅有一个直接后继元素。
  3. 数据元素之间的先后顺序为“一对一”的关系。

线性表

  • 数据元素之间逻辑关系为线性关系的数据元素集合称为线性表。

  1. 线性表的顺序存储（顺序表）：用一组地址连续的存储单元依次存储线性表的数据元素，数据元素之间的逻辑关系通过数据元素的存储位置直接反映。一般情况下采用数组存储。

  2. 线性表的链式存储（链表）：用一组地址任意的存储单元(连续的或不连续的)依次存储表中各个数据元素, 数据元素之间的逻辑关系通过指针间接地反映出来。

顺序表与链表的比较

  • 存储分配方式

    • 顺序存储用一段连续的存储单元依次存储线性表的数据元素
    • 链表采用链式储存结构，用一组不连续的存储单元存放线性表的元素

  • 时间性能

    • 查找

      • 顺序存储：无序O(n),有序O(log2 n)
      • 链表O(n)

    • 插入和删除

      • 顺序存储需要平均移动表长一半的元素，时间为O(n)
      • 链表在给出结点位置后，插入和删除时间仅为O(1)

  • 空间性能

    • 顺序存储需要事先分配存储空间，分大了浪费，分小了易发生溢出
    • 链表不需要事先分配存储空间，需要时分配结点，元素个数不受限制

在这里插入图片描述

二、链表的概念

定义：链表是一种物理存储上非连续、非顺序的存储结构，数据元素的逻辑顺序通过链表中的指针链接次序实现。

在这里插入图片描述

链表的结构：自引用结构

自引用结构分为两部分：

  1. 数据域：存储实际的数据
  2. 指针域：一个或多个指向自身结构类型的指针，用于存储数据的关系（如：下一个元素的位置）
//ElemType为数据类型，使用前需定义。
//如 #define ElemType int 或 typedef int ElemType
typedef struct node
{
    ElemType val;
    struct node *next;
}LNode,*LinkList;

链表的分类

单链表

在这里插入图片描述

双向链表
  • 双向链表是指链表的每一个结点中除了数据域以外设置两个指针域，其中之一指向结点的直接后继结点，另外一个指向结点的直接前驱结点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ucfwRP93-1683127239732)(图片/链表/双链表.png)]

循环链表
  • 循环链表是指链表中最后那个链结点的指针域存放指向链表最前面那个结点的指针，整个链表形成一个环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZQthHx5K-1683127239733)(图片/链表/循环链表.png)]

哨兵节点

在这里插入图片描述

  • 定义一个空结点（不存储任何数据），链表初始化时直接创建。

  • 该结点创建后，地址不做任何修改；链表的头指针指向哨兵节点

  • 第一个数据结点为头结点后面的第一个结点，后续操作只可能在

    头结点后面进行操作，不涉及任何头指针的修改

  • 设置头结点的最大好处是对链表结点的插入及删除操作统一了，不用单独考虑是否需要修改头指针。其数据域一般无意义（也可存放链表的长度）

三、单链表的基本操作

链表的创建

链表的创建可分为头插法和尾插法。

头插法

  • 在头节点后面插入新的节点，每个新产生的节点都会被接在头节点后面。

    在这里插入图片描述

LinkList create_head(int n)
{
    LinkList head =(LinkList)malloc(sizeof(LNode));
    head->val = n;//哨兵节点，方便插入与删除操作。如果ElemType类型为int可以存储链表的长度
    head->next = NULL;
    for (int i = 0; i < n;i++)
    {
        LinkList p=(LinkList)malloc(sizeof(LNode));
        p->next = NULL;
        scanf("%d", &p->val);//ElemType类型默认int
        p->next = head->next;
        head->next = p;
    }
    return head;
}
尾插法
  • 每个新节点都插在表尾

在这里插入图片描述

LinkList create_tail(int n)
{
    LinkList head =(LinkList)malloc(sizeof(LNode));
    head->val = n;//哨兵节点，方便插入与删除操作。如果ElemType类型为int可以存储链表的长度
    head->next = NULL;
    struct node *p=head, *q;
    for (int i = 0; i < n;i++)
    {
        q=(LinkList)malloc(sizeof(LNode));
        q->next = 0;
        scanf("%d", &q->val);//ElemType类型默认int
        p->next = q;
        p = p->next;
    }
    return head;
}

求线性链表的长度

int length(LinkList head)
{
    int num = 0;
    LinkList p = head->next;
    while(p)
    {
        num++;
        p = p->next;
    }
    return num;
    /*
    如果哨兵节点维护链表长度，直接输出哨兵节点数据
    return head->val;
    */
}

判断链表是否为空

int isempty(LinkList head)
{
    if(head->next)
        return 0;
    else
        return 1;
}

查找

按值查找
//查找成功，返回被查找节点地址，否则返回NULL
LinkList locate(LinkList head,ElemType item)
{
    LinkList p = head->next;
    while(p!=NULL&&p->val!=item)
        p = p->next;
    return p;
}
按序号查找
//查找成功，返回被查找节点地址，否则返回NULL
LinkList search(LinkList head,int i)
{
    int j = 0;
    LinkList p = head;
    while(p->next!=NULL&&j<i)
    {
        p = p->next;
        j++;
    }
    if(j==i)
        return p;
    else
        return NULL;
}

插入

在这里插入图片描述

尾结点插入
void add_node(LinkList head,int item)
{
    /*链表并非自己创造，手动添加哨兵节点
    LinkList dummy=(LinkList)malloc(sizeof(LNode));
    dummy->next=head;
    LinkList p = dummy;
    */
    LinkList p = head;
    LinkList q=(LinkList)malloc(sizeof(LNode));
    q->val = item;
    q->next = NULL;
    while(p->next!=NULL)
    {
        p = p->next;
    }
    p->next = q;
}
节点后插入
void insert_tail(LinkList p,ElemType item)
{
    LinkList q=(LinkList)malloc(sizeof(LNode));
    q->val = item;
    q->next = p->next;
    p->next = q;
}
节点前插入
void insert_head(LinkList head,LinkList p,ElemType item)
{
    LinkList pre = head;
    LinkList q=(LinkList)malloc(sizeof(LNode));
    q->val = item;
    while(pre->next!=p&&pre->next!=NULL)
        pre = pre->next;//找到p的前驱节点
    if(pre->next!=NULL)
    {
        q->next = pre->next;
        pre->next = q;
    }
    /*
    也可以将节点插入p节点后，然后交换两个节点数据，时间复杂度降低
    LinkList q=(LinkList)malloc(sizeof(LNode));
    q->val = item;
    q->next = p->next;
    p->next = q;
    ElemType tem=p->val;
    p->val=q->val;
    q->val=tem;
    */
}
按位置插入
//返回1则插入成功，返回0则插入失败，第i-1个节点不存在
int insert_pos(LinkList head,int i,ElemType item)
{
    LinkList p,q=(LinkList)malloc(sizeof(LNode));
    q->next = item;
    p = search(head, i - 1);
    if(p==NULL)
        return 0;
    else
    {
        q->next = p->next;
        p->next = q;
        return 1;
    }
}
有序链表插入
void insert_seq(LinkList head,ElemType item)
{
    LinkList p, q, r;
    r=(LinkList)malloc(sizeof(LNode));
    r->val = item;
    p = head;
    q = head->next;
    while (q != NULL&&item>=q->val)
    {
        p = q;
        q = q->next;
    }
    r->next = q;
    p->next = r;
}

删除

在这里插入图片描述

删除指定节点
void delete_node(LinkList head,LinkList p)
{
    LinkList pre = head;
    while(pre->next!=p&&pre->next!=NULL)
        pre = pre->next;//找到p的前驱节点
    if(pre->next!=NULL)
    {
        pre->next = p->next;
        free(p);
    }
}
按值删除节点
void delete_data(LinkList head,ElemType item)
{
    LinkList p = head,q;
    while(p->next!=NULL)
    {
        if(p->next->val==item)
        {
            q = p->next;
            p->next = p->next->next;
            free(q);
        }
        p = p->next;
    }
}
按位置删除节点
int delete_pos(LinkList head,int i)
{
    LinkList p, q;
    p = search(head, i - 1);
    if(p==NULL)
        return -1;
    else if (p->next == NULL)
        return 0;
    else
    {
        q = p->next;
        p->next = q->next;
        free(q);
        return 1;
    }
}
删除链表
void delete_list(LinkList head)
{
    LinkList p = head->next,q;
    while(p!=NULL)
    {
        q = p->next;
        free(p);
        p = q;
    }
}

反转链表

在这里插入图片描述

void reverse_list(LinkList head)
{
    LinkList p = head->next,q;
    head->next = NULL;
    while(p)
    {
        q = p;
        p = p->next;
        q->next = head->next;
        head->next = q;
    }
}

循环链表查找

LinkList search_circle(LinkList head,ElemType item)
{
    LinkList p = head->next;
    while(p!=head)
    {
        if(p->val==item)
            return p;
        p = p->next;
    }
    return NULL;
}
凌烟十八
关注
链表的知识总结
m0_67500944的博客
09-03 754
链表其实也算好理解的一种数据结构，其和顺序表不一样的是数据元素按逻辑次序链接在一起。本文用C++代码实践单链表，如有疑问一起讨论吧
链表基础知识总结
热门推荐
闲适_
02-28 1万+
什么是链表 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点都包括两部分：一是数据域，用来存储元素数值数据，另一个是存储直接后继结点地址的指针域，该指针一般称为next，用来指向下一个结点的位置。由于下一个结点也是链表类型，所以next的指针也要定义为链表类型。 链表中的一些基本定义和特点 头指针：是指向链表中第一个结点的指针 首元结点：是指链表中存储的第一个数据元素的结
一口气搞懂「链表」（学习使用）
最新发布
2302_78332636的博客
09-07 190
包含单链表，双链表，循环单链表，实际应用中的功能不同，但实现方式都差不多。单链表就像是美国男篮，一代一代往下传；双链表像是中国男足，你传球给我，我传球给你，最终传给了守门员；循环链表就像是中国男篮，火炬从姚明传给王治郅，王治郅传给易建联，现在易建联伤了，又传给了姚明单链表是指结点中只有一个指向其后继的指针，具有单向性，但是有时需要搜索大量数据的时候，就需要多次进行从头开始的遍历，这样的搜索就不是很高效了。
java链表知识点总结
weixin_34245749的博客
05-21 234
下面是一个Link类定义的一部分。它包含了一些数据和下一个链结点的引用：   ? 1 2 3 4 5 class Link {     public int data;     public int idata;     public Link next;//对下一个链结点的引用 } 这种类定义有时候叫做“自...
链表的基础知识
hello_JeremyWang的博客
01-13 584
0. 简介 最近在自己编写一些小的算法的时候，深感自己的算法过于臃肿。碰巧Datawhale在新的一期组队学习中组织了数据结构与算法的课程学习。于是就参加了，再次感谢Datawhale~~ 首先跟大家分享一下两个自己感觉比较好的学习资料，一个是 算法通关手册 ，也是Datawhale在本次组队学习中的学习资料；一个是B站上的视频 【北京大学】数据结构与算法Python版（完整版），老师讲的特别棒（也难得有Python版的数据结构课程，哈哈~）。 1.链表的简介 链表（Linked List）：一种线性表
链表知识点总结
Lookdrama的博客
10-27 1148
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。每一个结构均含有元素和指向该元素后继结构的指针。
C++ 链表知识，请各位欣赏，谢谢了
12-21
链表是一种基础且重要的数据结构，它在计算机科学和编程，尤其是C++中扮演着核心角色。链表与数组不同，不连续存储元素，而是通过节点间的引用（指针）来连接元素。在这个主题中，我们将深入探讨C++中的链表，包括其...
python的链表基础知识点
12-17
总结来说，链表是一种灵活的数据结构，它通过节点和指针实现了元素的非连续存储。在Python中，虽然没有内置的链表类型，但可以通过自定义类来实现链表的各种操作，以适应不同的算法和程序设计需求。理解链表的基本...
Leetcode 链表知识点总结
大锅八十小锅四十
02-17 1099
来看下Leetcode中Tag为[ Linked-List ]（https://leetcode.com/tag/linked-list/ ）的题目[ 141. Linked List Cycle ]（https://leetcode.com/problems/linked- list-cycle / description / ）：判断一个链表是否存在环，Easy [ 142.链接列表循环II ...
关于c语言链表的学习总结
07-21
从提供的内容中可以提炼出几个关键知识点：链表的定义、链表元素的添加、链表长度的计算、链表中元素的查找，以及链表操作中可能遇到的问题和解决方法。 链表是一种由节点组成的线性结构，每个节点包含数据和指向下...
链表基础知识详解（非常详细简单易懂）
酒无忧的博客
04-19 1210
链表作为C语言中一种基础的数据结构，在平时写程序的时候用的并不多，但在操作系统里面使用的非常多。不管是RTOS还是Linux等使用非常广泛，所以必须要搞懂链表，链表分为单向链表和双向链表，单向链表很少用，使用最多的还是双向链表。单向链表懂了双向链表自然就会了。
链表基础知识
小菜鸡
03-08 712
链表 基础知识 关于链表，你该了解这些！ 什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。 链接的入口节点称为链表的头结点也就是head。 如图所示： 链表的类型 接下来说一下链表的几种类型: 单链表 刚刚说的就是单链表。 双链表 单链表中的节点只能指向节点的下一个节点。 双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。 双链表 既可以向前查询也可以向
链表基础知识整理
xuan971130的博客
07-27 1022
关于链表最重要的是搞清楚指针的指向，next域存放的是下一个结点的地址。1：顺序建链表要定义头指针，游动指针，尾部指针； 逆序建立链表定义头指针和游动指针即可，每次将新的结点插在头指针后面。搞清楚指针的指向即可。2：删除结点。定义一个游动指针，还要定义一个指针，为了记后一个结点的地址。 顺序建表： #include #include struct node { int data
链表基础知识梳理
c123nANDY的博客
12-17 330
链表是乱序的多组数据相互联系构成的 链表操作分为：初始化，创建，插入，删除，遍历，查询，逆序，是否有环 链表定义 typedef struct LinkList { int Element; LinkList * next; }LinkList; 初始化 linklist * List_init() { linklist *HeadNode= (linklist...
链表总结
LHu~
02-20 420
链表面试总结
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值