【第二章 - 线性表之单链表】- 数据结构

最新推荐文章于 2024-07-25 17:43:13 发布
最新推荐文章于 2024-07-25 17:43:13 发布
阅读量349 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/melonyzzZ/article/details/129277310
版权

目录

一、单链表的定义和表示

二、单链表基本操作的实现

2.1 - 不设头结点的单链表

2.2 - 设头结点的单链表

一、单链表的定义和表示

线性表的链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。

用单链表（Single Linked List）表示线性表时，为了表示每个数据元素与其直接后继数据元素之间的逻辑关系，对每个数据元素来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。这两部分信息组成数据元素的存储映像，称为结点（node）。它包括两个域：其中存储数据元素信息的域称为数据域；存储直接后继存储位置的域称为指针域。指针域中存储的信息称作指针或链。

根据链表结点所含指针个数、指针指向和指针连接方式，可将链表分为单链表（每个结点只包含一个指针域）、循环链表、双向链表、二叉链表、十字链表、邻接表、邻接多重表等。其中单链表、循环链表和双向链表用于实现线性表的链式存储结构，其他形式多用于实现树和图等非线性结构。

单链表可由头指针唯一确定，在 C 语言中可用"结构指针"来描述：

typedef struct SLLNode
{
	SLLDataType data;  // 结点的数据域
	struct SLLNode* next;  // 结点的指针域
}SLLNode, *SLinkList;

SLinkList 与 SLLNode*，两者本质上是等价的。通常习惯上用 SLinkList 定义单链表，强调定义的是某个单链表的头指针；用 SLLNode* 定义指向单链表中的任意结点的指针变量。

单链表是由表头指针唯一确定的，因此单链表可用用头指针的名字来命名。若头指针名是 L，则简称该单链表为表 L。

一般情况下，为了处理方便，在单链表的第一个结点之前附设一个结点，称之为头结点。

下面对首元结点（新概念）、头结点、头指针三个容易混淆的概念加以说明：

  1. 首元结点是指链表中存储第一个数据元素的结点。

  2. 头结点是在首元结点之前附设的一个结点。

  3. 头指针是指向链表中第一个结点的指针。

    • 若链表设有头结点，则头指针所指结点为线性表的头结点，即：

    • 若链表不设头结点，则头指针所指结点为该线性表的首元结点，即：

单链表是非随机存取的存储结构，要取得第 i 个数据元素必须从头指针出发顺链进行寻找，也称为顺序存取的存储结构。因此，其基本操作的实现不同于顺序表。

二、单链表基本操作的实现

2.1 - 不设头结点的单链表

SLinkList.h：

#pragma once

// 不设头结点的单链表
typedef int SLLDataType;

typedef struct SLLNode
{
	SLLDataType data;  // 结点的数据域
	struct SLLNode* next;  // 结点的指针域
}SLLNode, *SLinkList;

// 基本操作
void SLinkListInit(SLinkList* pphead);  // 初始化

SLLNode* BuySLLNode(SLLDataType e);  // 动态申请一个新结点

void SLinkListPushBack(SLinkList* pphead, SLLDataType e);  // 尾插
void SLinkListPopBack(SLinkList* pphead);  // 尾删

void SLinkListPushFront(SLinkList* pphead, SLLDataType e);  // 头插
void SLinkListPopFront(SLinkList* pphead);   // 头删

void SLinkListInsertAfter(SLLNode* pos, SLLDataType e);  // 在 pos 之后插入
void SLinkListEraseAfter(SLLNode* pos);  // 删除 pos 之后的结点

void SLinkListInsertBefore(SLLNode* pos, SLLDataType e);  // 在 pos 之前插入
void SLinkListErase(SLinkList* pphead, SLLNode* pos);  // 删除 pos 结点
void SLinkListEraseNonTail(SLLNode* pos);  // 删除 pos 非尾结点 

SLLNode* SLinkListFind(const SLinkList phead, SLLDataType e);  // 查找

void SLinkListPrint(const SLinkList phead);  // 打印

SLinkList.c：

  1. 初始化：

    void SLinkListInit(SLinkList phead)
{
    phead = NULL;
}

    单链表的初始化操作就是构造一个空表，即将头指针置为空。

    但是该函数无法初始化单链表，因为传值调用时，修改形参并不会影响实参，即如果要将头指针置为空，那么传给函数的实参就应该是头指针的地址，形参则应该是一个二级指针。

    修正：

    void SLinkListInit(SLinkList* pphead)
{
    assert(pphead);
    *pphead = NULL;
}

    pphead 是指向头指针的指针，它不能为空，对空指针解引用会导致运行时的错误。

    由于有传入 NULL 的风险，所以先进行断言，提高代码的健壮性。

  2. 动态申请一个新结点：

    SLLNode* BuySLLNode(SLLDataType e)
{
    SLLNode* newnode = (SLLNode*)malloc(sizeof(SLLNode));
    if (NULL == newnode)
    {
        perror("malloc failed!");
        return NULL;
    }
    newnode->data = e;
    newnode->next = NULL;   // 将结点的指针域置为空
    return newnode;
}

  3. 尾插：

    void SLinkListPushBack(SLinkList* pphead, SLLDataType e)
{
    assert(pphead);
    SLLNode* newnode = BuySLLNode(e);
    if (*pphead == NULL)  // 如果表为空
    {
        *pphead = newnode;
    }
    else
    {
        SLLNode* tail = *pphead;
        while (tail->next != NULL)
        {
            tail = tail->next;
        }
        tail->next = newnode;
    }
}

    尾插的重点是找到尾结点，尾结点的特点是其 next 成员的值为 NULL，即 tail->next == NULL。

    因为尾插时单链表可能为空，需要修改头指针，所以形参仍需要用一个二级指针 SLinkList* pphead 来接受头指针的地址 &phead。

  4. 尾删：

    法一：

    void SLinkListPopBack(SLinkList* pphead)
{
    assert(pphead);
    // 判断是否为空表
    if (*pphead == NULL)
    {
        return;
    }
    // 尾删
    if ((*pphead)->next == NULL)  // 如果表中只包含一个结点
    {
        free(*pphead);
        *pphead = NULL;
    }
    else
    {
        SLLNode* pre_tail = *pphead;
        SLLNode* tail = (*pphead)->next;
        while (tail->next != NULL)
        {
            pre_tail = tail;
            tail = tail->next;
        }
        free(tail);
        tail = NULL;
        pre_tail->next = NULL;
    }
}

    删除操作首先要判断表是否为空，其次该尾删操作是通过找到尾结点和倒数第二个结点实现的，因此就需要先考虑表中只含一个结点的情况，在这种情况下需要删除唯一的结点，并将头指针置为空，即涉及到修改了头指针。

    法二：

    void SLinkListPopBack(SLinkList* pphead)
{
    assert(pphead);
    // 判断是否为空表
    if (*pphead == NULL)
    {
        return;
    }
    // 尾删
    if ((*pphead)->next == NULL)  // 如果表中只包含一个结点
    {
        free(*pphead);
        *pphead = NULL;
    }
    else
    {
        SLLNode* pre_tail = *pphead;
        while (pre_tail->next->next != NULL)
        {
            pre_tail = pre_tail->next;
        }
        free(pre_tail->next);
        pre_tail->next = NULL;
    }
}

    该尾删操作是通过直接找到倒数第二个结点实现的，也需要考虑到表中只包含一个结点的情况。

  5. 头插：

    void SLinkListPushFront(SLinkList* pphead, SLLDataType e)
{
    assert(pphead);
    SLLNode* newnode = BuySLLNode(e);
    newnode->next = *pphead;
    *pphead = newnode;
}

    头插必然涉及到修改头指针。

    注意：newnode->next = *pphead; 和 *pphead = newnode 的顺序不能发生改变。

  6. 头删：

    void SLinkListPopFront(SLinkList* pphead)
{
    assert(pphead);
    // 判断是否为空表
    if (*pphead == NULL)
    {
        return;
    }
    // 头删
    SLLNode* first = *pphead;
    *pphead = first->next;
    free(first);
    first = NULL;
}

    头删也必然涉及到修改头指针。

  7. 在 pos 之后插入：

    void SLinkListInsertAfter(SLLNode* pos, SLLDataType e)
{
    assert(pos);
    SLLNode* newnode = BuySLLNode(e);
    newnode->next = pos->next;
    pos->next = newnode;
}

  8. 删除 pos 之后的结点：

    void SLinkListEraseAfter(SLLNode* pos)
{
    assert(pos && pos->next);  // pos 不能为空且不能指向尾结点
    SLLNode* tmp = pos->next;  // tmp 指向 pos 之后的结点
    pos->next = pos->next->next;  // 或者 pos->next = tmp->next;
    free(tmp);
    tmp = NULL;
}

  9. 在 pos 之前插入：

    void SLinkListInsertBefore(SLLNode* pos, SLLDataType e)
{
    assert(pos);
    SLLNode* newnode = BuySLLNode(e);
    // 先在 pos 之后插入
    newnode->next = pos->next;
    pos->next = newnode;
    // 再交换两个结点的数据
    SLLDataType tmp = newnode->data;
    newnode->data = pos->data;
    pos->data = tmp;
}

  10. 删除 pos 结点：

    void SLinkListErase(SLinkList* pphead, SLLNode* pos)
{
    assert(pphead);
    assert(pos);  // 若 pos != NULL，则意味着 phead != NULL
    if (pos == *pphead)
    {
        SLinkListPopFront(pphead);
    }
    else
    {
        SLLNode* pre = *pphead;
        while (pre->next != pos)
        {
            pre = pre->next;
        }
        pre->next = pos->next;
        free(pos);
        pos = NULL;
    }
}

  11. 删除 pos 非尾结点：

    void SLinkListEraseNonTail(SLLNode* pos)
{
    assert(pos && pos->next);  // pos 不能为空且不能指向尾结点
    SLLNode* tmp = pos->next;  // tmp 指向 pos 之后的结点
    pos->data = tmp->data;
    pos->next = tmp->next;
    free(tmp);
    tmp = NULL;
}

  12. 查找：

    SLLNode* SLinkListFind(const SLinkList phead, SLLDataType e)
{
    const SLLNode* cur = phead;
    while (cur != NULL)
    {
        if (cur->data == e)
        {
            return (SLLNode*)cur;
        }
        cur = cur->next;
    }
    return NULL;
}

  13. 打印（不通用）：

    void SLinkListPrint(const SLinkList phead)
{
    const SLLNode* cur = phead;
    while (cur != NULL)
    {
        printf("%d->", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
}

2.2 - 设头结点的单链表

链表增加头结点的作用如下：

  1. 便于首元结点的处理。

    增加了头结点后，首元结点的地址保存在头结点（即其"前驱"结点）的指针域中，则对链表的第一个数据元素的操作与其他数据元素相同，无需进行特殊处理。

  2. 便于空表和非空表的统一处理。

    当链表不设头结点时，假设 phead 为单链表的头指针，它应该指向首元结点，则当单链表为长度 n 为 0 的空表时，phead 指针为空（判定空表的条件可记为：phead == NULL）。

    增加头结点后，无论链表是否为空，头指针都是指向头结点的非空指针。若为空表，则头结点的指针域为空（判定空表的条件可记为：phead->next == NULL）。

设头结点的单链表与不设头结点的单链表在基本操作的实现上逻辑是相似的，需要注意的是：

  1. 初始化：

    void SLinkListInit(SLinkList* pphead)
{
    assert(pphead);
    SLLNode* newnode = BuySLLNode(0);  // 生成一个新结点作为头结点
    if (NULL == newnode)
    {
        printf("initialization failed!");
        return;
    }
    *pphead = newnode;  // 让头指针指向头结点
}

  2. 在实现插入、删除等操作时，不涉及头指针的修改，函数形参可以是一个一级指针。

  3. 由于单链表带表头结点，那么首先应该判定头指针是否为空，即 assert(phead)。

欲知后事如何，且听下回分解~

melonyzzZ
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【数据结构】第二章 线性表（二）单链表
qq_45653724的博客
11-07 257
笔记【数据结构】第二章 线性表（二） 1 单链表 通过指针把它的一串存储结点链接成一个链 存储结点由两部分组成： data字段 ，link字段 单链表的存储映像 结点之间可以连续，也可以不连续存储; 结点的逻辑顺序与物理顺序可以不一致; 表可扩充。 在C++中，可以用结构类型来描述单链表的结点 ，由于结点的元素类型不确定，所以采用C++的模板机制。 template <typename T&...
【数据结构】线性表的链式存储结构--单链表
wupenm的专栏
09-18 5859
单链表的创建、插入、删除等基本操作的实现
单链表的定义
hibugs
07-06 5734
在前面的文章中，我们系统的介绍了线性表的顺序存储实现——顺序表。紧接着我们要介绍线性表的链式存储实现——链表。而链表中又有许多的链表：这一篇文章中，我们先来介绍单链表。要想知道什么是单链表，我们就可以使用我们学习过的顺序表来对比学习（对比学习有助于你的记忆，使用学习过的知识去学习未知的知识，也未尝不是一种好方法）我们都知道顺序表是申请一大块连续的区域，并且使用物理地址相邻的方法来表示逻辑上的相邻。而链表逻辑上相邻的元素在内存中可以是不相邻存放的。那么如果链表中的元素在内存中不是相邻存放的，那我们如何知道下一
单链表详解（C语言版）
热门推荐
qq_44075108的博客
09-27 2万+
本文介绍单链表的定义、常用操作、优化和使用的注意点等内容。
数据结构（一）——单链表
初叙
11-28 747
一、顺序存储结构 把数据放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的。 顺序表（一） 数据域：存储数据元素信息的域。 指针域：存储直接后继的域。指针域中存储的信息称为指针或链。 结点：由数据域和指针域组成数据元素的存储影像。 链表：n个结点链接成一个链表。 头指针：链表中第一个结点的存储位置。整个链表的存取必须是从头指针开始进行。 尾指针：线性链表的最后一个结点为...
【数据结构】单链表--List
Z1tai的博客
05-12 1万+
概念：链表是一种物理存储结构上非连续非顺序的存储结构，但链表在逻辑上是连续的，顺序的，而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。
单链表的定义(数据结构与算法)
AII_IIA的博客
10-26 1056
单链表是一种常见的数据结构，用于存储元素的序列。它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用（指针）。单链表中的节点之间通过指针连接起来，形成一个线性结构。单链表是一种简单但灵活的数据结构，常用于实现队列、堆栈和图等其他高级数据结构。
《数据结构》第二章线性表习题.doc
12-01
本资源摘要信息对应的知识点主要涉及到数据结构的第二章线性表习题，包括线性表的定义、链式存储、顺序存储、单链表、双向循环链表、栈和队列等概念。 一、线性表的定义 线性表是指一个有限序列，可以为空。它的每...
数据结构练习题-第二章--线性表-习题及答案.doc
10-12
数据结构练习题 - 第二章 - 线性表 - 习题及答案 本资源是数据结构练习题的第二章，主要讲解线性表的概念、特征、操作和实现。下面是本资源的详细知识点： 线性表基本概念 * 线性结构：一种数据结构，以一种线性...
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
目前最完整的数据结构1800题包括完整答案-第二章-线性表.doc
10-10
线性表是数据结构中的基础概念，通常包含两种主要的存储结构：顺序存储和链式存储。本章涉及的题目主要考察这两种存储结构的特点、优缺点以及操作效率。 1. **顺序存储结构**： - 优点：存储密度大，即单位存储...
数据结构之单链表
容铎的博客
04-30 1213
数据结构之单链表
单链表的定义和操作(超详细——C语言)
weixin_47783699的博客
10-15 3063
你还在为学习链表而烦恼？你还在为老师讲的不够简单？？你是否还在苦苦挣扎着。跟我走,我带你征服链表。
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 5081
数据结构深度学习之单链表非常详解解读~~~一万多字详解
【数据结构】线性表-单链表（图解、c++、java）
扑腾的江鱼复习仓库
01-13 1156
URLeisure的单链表“完美”复习资料。
单链表的定义，插入与删除，查找，建立。
liyulin90的博客
04-20 3335
链表分为：单链表，双链表，循环链表，静态链表 一，单链表的定义 在内存空间中，各个节点在逻辑上相邻，但在物理上不相邻。 在单个的结点内部需要存放 数据域 和 指针域（存放指向下一个结点的指针） 优点：不要求一大片连续空间，改变容量方便 缺点：不可随机存取，要耗费一定的空间存放指针。 定义 typedef struct LNode{ //定义单链表结点类型 int data; //每个节点存放一个数据元素 struct LN...
线性表—单链表
qq_39172845的博客
03-16 1122
C++模板类实现单链表以及常用操作
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1534
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构第二章-线性表详解
"本章小结-数据结构第二章，主要涵盖了线性表的基本概念、顺序存储和链式存储的特点，以及单链表、双向链表和循环链表的介绍。" 在数据结构中，线性表是一个重要的基础概念，它是由n个数据元素构成的有限序列，每个...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值