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

已于 2024-04-27 19:42:19 修改
阅读量1.1k 收藏 15
点赞数 33
分类专栏： 数据结构 文章标签： 数据结构 图论
于 2024-04-27 19:34:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kx_52517/article/details/138255846
版权

请添加图片描述

第二章 线性数据结构.线性表.单链表

[5] 单链表的定义

1.单链表

逻辑结构：是一种线性表。

请添加图片描述

顺序表（顺序存储）：

  • 优点：可随机存取，存储密度高
  • 缺点：要求大片连续空间，改变容量不方便
  • 特点：每个结点中只存放数据元素

单链表（链式存储）：

  • 优点：不要求大片连续空间，改变容量方便
  • 缺点：不可随机存取，要耗费一定空间存放指针
  • 特点：每个结点除了存放数据元素外，还要存储指向下一个结点的指针

请添加图片描述

2.用代码定义单链表

struct LNode {
    ElemType data;
    struct LNode *next;
}
struct LNode* p = (struct LNode*) malloc(sizeof(struct LNode));

上面的写法比较繁琐，因此用typedef进行重定义：

typedef struct LNode {           // 定义单链表结点类型
    ElemType data;              // 每个结点存放一个数据元素
    struct LNode *next;         // 指针指向下一个结点
} LNode, *LinkList;

以下有两种定义：其中

LNode * L;

声明一个指向单链表第一个结点的指针，结构体指针，主要强调这是一个结点。

LinkList L;

声明一个指向单链表第一个结点的指针，结构体指针，主要强调这是一个单链表。

请添加图片描述

二者的表示是等价的，但是后者代码可读性更强。

3.初始化单链表

  • 不带头结点的单链表
typedef struct LNode {           // 定义单链表结点类型
    ElemType data;              // 每个结点存放一个数据元素
    struct LNode *next;         // 指针指向下一个结点
} LNode, *LinkList;

bool InitList(LinkList &L) {
    // 防止出现脏数据
    L = NULL;                   // 空表，暂时还没有任何结点
    return true;
}

void test()
{
    // 声明一个指向单链表的指针，这里的L是结构体指针
    // 注意此处并没有创建一个结点
    LinkList L;
    //初始化一个空表
    InitList(L);
    //......后续代码....
}
  • 带头结点的单链表
typedef struct LNode {          // 定义单链表结点类型
    ElemType data;              // 每个结点存放一个数据元素
    struct LNode *next;         // 指针指向下一个结点
} LNode, *LinkList;

// 初始化一个单链表(带头结点)
bool InitList(LinkList &L){
    // 分配头结点
    L = (LNode*) malloc(sizeof(LNode));

    // 判断是否分配成功
    if (NULL == L) {
         return false;
    }
    // 头结点后暂时没有存放数据
    L->next = NULL;
    return true;
}

void test(){
    // 声明一个指向单链表的指针，这里的L是结构体指针
    // 注意此处并没有创建一个结点
    LinkList L;
    // 初始化一个空表
    InitList(L);
    //......后续代码....
}

不带头结点，写代码更麻烦，需要对第一个数据结点和后续数据结点的处理，需要用不同的代码逻辑，对空表和非空表的处理需要用不同的代码逻辑。带头结点，一套代码完成，实现更方便。

以下代码如果不做特殊说明，则都指包含头结点。

请添加图片描述

[6] 单链表的插入删除

1.按照位序插入

带头结点

首先以带头结点为例子，实现插入：

// 在表 L 中的第 i 个位置上插入了指定元素e，
// 注意：这里的i表示的是位序，即前i - 1的元素均保持不动，新的元素的新位序是i，原位序 i 后的结点依次推移。
ListInsert(&L, i, e);

插入过程分以下几步：

  1. 遍历找到第 i - 1 个结点；
  2. 分配新结点，填充数据域；

请添加图片描述

  1. 新结点后继为所寻结点的后继，新结点成为所寻结点的后继。

请添加图片描述

  1. 插入完成。

程序实现:

typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

// 在第 i 个位置插插入元素e ，链表带头结点
bool ListInsert(LinkList &L, int i, ElemType e)
{
    if (i < 1) {
        return false;
    }
        
    LNode *p;   // 结构体指针p, 指向当前扫描到的结点
    int j = 0;  // 当前p指向的是第j个结点
    p = L;      // L 指向头结点，头结点是第0个结点(不存数据)

    // 循环找到第 i - 1 个结点
    // 非空表示不能到链表尽头了，j < i - 1，表示要找到第 i - 1 个结点就停下来了
    while (p != NULL && j < i - 1) {      
        p = p->next;
        j++;
    }

    // 到这里 p 指向了第 i - 1 个结点
    // 校验发现第 i - 1个结点是空的，这就表示原链表只有 i - 2 个结点，第 i - 2 个结点的后继是空指针。
    if (p == NULL) {            
        return false;
    }

    LNode *s = (LNode *)malloc(sizeof(LNode));
    // malloc 返回值必须校验
    if (s == NULL) {
        return false;
    }
    s->data = e;
    s->next = p->next; 
    p->next = s;    // 将结点s连到p之后
    return true;    // 插入成功
}

因为遍历结点是n阶，因此，时间复杂度：O(N)。

不带头结点

再以不带头结点为例子，实现插入，由于不带头结点，不存在“第0个”结点。

插入方法：

  1. 如果是首个添加结点，直接分配，插入作头结点。
  2. 如果不是首个添加结点，遍历找到第 i - 1 个结点；
  3. 分配新结点，填充数据域；
  4. 新结点后继为所寻结点的后继，新结点成为所寻结点的后继。
  5. 插入完成。
typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

bool ListInsert(LinkList &L，int i,ElemType e){
    if (i < 1) {
        return false;
    }

    if (i == 1) {
        LNode *s = (LNode*)malloc (sizeof(LNode));
        if (s == NULL) {
            return false;
        }
        s->data = e;      // 给数据域赋值
        s->next = L;      // 新指针，代替指向原来的头结点的指针
        L = s;            // 用L指针指向现在的新头结点
        return true;
    }

    // 以下过程同代头结点插入过程类似
    LNode* p;
    int j = 1;         // 当前p指向了第1个结点;
    p = L;
    while (p != NULL && j < i - 1){
        p = p->next;
        j++;
    }

    // 循环找到第 i - 1 个结点
    if (p == NULL)      
    {
        return false;
    }
        
    LNode* s = (LNode*)malloc(sizeof(LNode));
    if (s == NULL) {
        return false;
    }
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

结论：不带头结点的场景，对插入位序为 1 的情况做特殊处理，得考虑两种情况，写代码更不方便，推荐用带头结点，一套代码兼容所有场景。

因此，以下的代码实现均以包含头结点为例子。

2.在某个指定结点后插元素

请添加图片描述

这个过程实际上就是在“按位序插入的基础上”，省略了遍历寻找结点的过程。直接对结点进行插入操作。

// 在p结点后插入元素 e
bool InsertNextNode(LNode* p, ElemType e)
{
    if (p == NULL) {
        return false;
    }
    
    LNode *s = (LNode*)malloc(sizeof(LNode));
    // 判定内存是否申请成功
    if (s == NULL) {
        return false;
    }
  
    // 链表插入数据分三步，填数，建后继链，断前驱链
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

该算法的时间复杂度是O(1)。

3.在某个指定结点前插元素

方法1：常规算法

// 循环遍历查找p的前驱，再对q后插。
InsertPriorNode(Linklist L, LNode *p, ElemType e);

常规做法，是遍历找到那个结点的前驱结点，对前驱结点执行插入操作。

请添加图片描述

程序实现:

bool InsertPriorNode(Linklist L, LNode *p, ElemType e)
{
    if (p == NULL) {
        return false;
    }

    LNode * pre = L;   // 前驱结点
    // 遍历循环查找
    while (pre != NULL) {
        if (pre->next == p) {
            break;
        }
        pre = pre->next;
    }

    // 如果找不到，那就是空值
    if (pre == NULL) {
        return false;
    }

    // 直接调用指定结点后插元素，在p的前一个结点插入，即是在p的前驱结点的后一个插入
    return InsertNextNode(pre, e);
}

这种算法，必须依赖有链表头。
该算法的时间复杂度是O(N) 。

方法2：交换结点算法

还有另一种算法，本质是Swap替换。
插入方法：

  1. 直接对指定结点进行后插操作。
  2. 交换新结点与指定结点的数据域；
  3. 插入成功；

请添加图片描述

bool InsertPriorNode(LNode *p, ElemType e)
{
    if (p == NULL) {
        return false;
    }

    LNode *s = (LNode*)malloc(sizeof(LNode));
    // 判定内存是否申请成功
    if (s == NULL) {
        return false;
    }

    // 解链，重新成链
    s->next = p->next;
    p->next = s;
    
    // 数据交换swap
    s->data = p->data;
    p->data = e;
    return true;
}

看上去是一种在指定结点的后向插入，但是交换完数据后，后继变成了前驱。
该算法的时间复杂度是O(1).

[7] 单链表的删除

1.按位序删除

// 删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。
ListDelete(&L, i, &e);

方法：
以带头结点的链表为例，头结点可以看作“第0个”结点，遍历找到第 i-1 个结点，将其指针指向第 i+1 个结点，并释放第 i 个结点。
请添加图片描述

请添加图片描述

bool ListDelete(Linklist &L, int i, ElemType &e)
{
    if (i < 1) {
        return false;
    }
        
    LNode *p;   // 结构体指针p, 指向当前扫描到的结点
    int j = 0;  // 当前 p 指向的是第 j 个结点
    p = L;      // L 指向头结点，头结点是第0个结点(不存数据)

    // 循环找到第 i-1 个结点
    while (p != NULL && j < i - 1) {      
        p = p->next;
        j++;
    }

    if (p == NULL) {
        return false;   // i值不合法
    }       
    
    // 第i-1个结点后没有其他结点，不存在第i个结点
    if (p -> next == NULL) {
        return false;   
    }
    // 到这里的代码都和指定位序插入结点相同
    
    LNode *q = p->next;       // 令q指向被删除结点，即临时变量
    e = q->data;              // 用e把返回值带回来
    p->next = q->next;        // 将*q结点从链中断开
    free(q);                  // 释放结点的存储空间
    return true;              // 删除成功
}

该算法的时间复杂度是O(N)

2.指定结点的删除

对于指定结点删除与"在某个指定结点前插元素"类似，有两种方法。

方法1：常规遍历

传入头指针 L ，循环寻找 p 的前驱结点，与某个指定结点前插元素方法1类似，暂时作省略。

方法2：交换结点数据域

第二种方式，类似于结点前插的实现，“偷天换日”。

  1. 临时结点，存储指定结点的下一个结点；
  2. 指定结点与下一个结点交换数据域；
  3. 删除指定结点的下一个结点（临时结点），此时临时结点内的数据已经保存替换，而指向了继续的结点；
  4. 释放临时结点。

请添加图片描述

以下以方法2为例，用代码实现：

bool DeleteNodeBySwap(LNode *p, ElemType &e)
{
    // 校验是否符合条件
    if (p == NULL || p->next == NULL) {
        return false;
    }

    e = p->data;
    
    LNode *q = p->next;         // 令q指向*p的后继结点
    p->data = p->next->data;    // 和后继结点交换数据域
    p->next = q->next;          // 将*q结点从链中断开
    free(q);
    return true;
}

以上的时间复杂度是O(1)。
注意，以上删除方式依赖p的下一个结点一定不是空，必须要有数据域，这样才有交换的前提。
从语法上，对空指针解引用 p->next->data也是非合法操作。如果p是最后一个结点，即下一个结点并不存在，那么只能从表头开始依次寻找p的前驱，时间复杂度 O(N)。

[8] 单链表的查找

链表的查找与顺序表类似，分为按位和按值查找，一个是已知序号求值，一个是已知值求序号（结点）。

1.按位查找

// 按位查找，获取L中的第i个为主的元素的值。
GetElem(L, i);

代码实现：

LNode* GetElem(Linklist L,int i)
{
    if (i < 0) {
        return NULL;
    }
    LNode *p;
    int j = 0;
    p = L;
    while (p != NULL && j < i) {
        p = p->next;
        j++;
    }
}

时间复杂度 O(N)。

2.按值查找

// 按值查找，在表L中查找具有给定关键字值的元素。
LocateElem(L, e);

代码实现：

LNode * LocateElem(LinkList L, ElemType e)
{
    LNode *p = L->next;
    // 从第一个结点开始查找数据域为e的结点
    while (p != NULL && p->data != e) {
        p = p->next;
    }
    return p;     // 找到后返回该结点指针，否则返回NULL
}

时间复杂度 O(N)

3.求表的长度

遍历表从表头指表尾，每次迭代，长度自增。
代码实现：

// 包含头结点，仅有头结点，长度为0
int GetLength(LinkList L)
{
    int len = 0;
    LNode *p = L;
    while (p->next != NULL) {
        p = p->next;
        len++;
    }
    return len;
}

[9] 单链表的建立

单链表的建立，主要分两步：

  1. 初始化单链表；
  2. 将元素逐个插入到链表中。

1.尾插法

尾插法，顾名思义，将结点一个一个依次插入到链表尾部。
算法利用伪代码实现：

首先初始化一个链表，
设置变量length记录链表长度
while (没有取完) {
    每次取一个数据元素e;
    ListInsert(L, length+1, e)，插到尾部；
    length++;
}

常规做法

每次取新结点，都从头结点开始遍历到尾部，然后将结点插入到尾部。
代码实现：

bool ListInsert(LinkList &L, int i, ElemType e)
{
    if (i < 1) {
        return false;
    }    
    LNode *p;
    int j = 0;
    p = L;

    // 循环找到第 i-1 个结点
    while (p != NULL && j < i - 1) {
        p = p->next;
        j++;
    }
    if (p== NULL) {
        return false;
    }

    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s == NULL) {
        return false;
    }
    
    // 开始插入
    s->data = e;
    s->next = p->next;
    p->next = s;         // 把结点s连到p之后
    return true;
}

以上的时间复杂度是 O ( N 2 ) O(N^2) O(N2) ,并不好。

算法优化

变化思路，将链表值依次输入，并使用一个临时变量记录尾部结点。

请添加图片描述

LinkList List_TailInsert(LinkList &L)
{   
    // 正向建立单链表
    int x;                                // ElemType -> 整型
    L = (LinkList)malloc(sizeof(LNode));  // 头结点
    if (L == NULL) {
        return NULL;
    }
    
    LNode *s, *r = L;                      // r为表尾指针
    while(scanf("%d", &x) != EOF){
        s = (LNode*)malloc(sizeof(LNode));
        if (s == NULL) {
            // ... 清理内存代码...
            return NULL;
        }

        s->data = x;
        r->next = s;
        r = s;
    }
    r->next = NULL;
    return L;
}

以上的时间复杂度是O(N)。

2.头插法

头插法是一个对指定结点的核心操作。
具体方法：

初始化单链表
while (没有取完) {
    每次取一个数据元素e;
    ListInsertNode(L,e);
}

请添加图片描述

代码实现：

LinkList List_HeadInsert(LinkList &L)
{
    LNode *s;
    int x;
    L = (Linklist)malloc(sizeof(LNode));    // 创建头结点
    if (L == NULL) {
        return NULL;
    }
    L->next = NULL;
    while (scanf("%d",&x) != EOF) {
        s = (LNode*)malloc(sizeof(LNode));
        if (s == NULL) {
            // ... 清理内存代码...
            return NULL;
        }
        s->data = x;
        s->next = L->next;
        L->next = s;
    }
    return L;
}

注意：
养成好习惯，只要是初始化指针，都需要先把头指针指向NULL。

尾插法，十分适用于链表逆置。

曾经``沧海
关注
  • 33
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 1852
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
数据结构（C语言版） 第二章 线性表 知识梳理+作业习题详解
繁凡さん的博客
04-29 6万+
单链表顺序存储结构 单链表强调元素在逻辑上紧密相邻，所以首先想到用数组存储。但是普通数组有着无法克服的容量限制，在不知道输入有多少的情况下，很难确定出一个合适的容量。对此，一个较好的解决方案就是使用动态数组。首先用malloc申请一块拥有指定初始容量的内存，这块内存用作存储单链表元素，当录入的内容不断增加，以至于超出了初始容量时，就用calloc扩展内存容量，这样就做到了既不浪费内存，又可以让单链...
【王道数据结构】第二章 线性表
weixin_48434658的博客
07-16 418
线性表(LinearList)的定义线性表的基本操作什么时候要传入参数的引用**“&”**——对参数的修改结果需要“带回来”顺序表的实现——静态分布顺序表的实现——动态分配顺序表特点什么是单链表用代码定义一个单链表🎈结点的表示即后可写为🎈定义一个单链表获取第i位结点（带头结点）两种实现方式🎨不带头结点🎨带头结点🎨不带头结点V.S.带头结点。...
数据结构总结 第二章 线性表——单链表
weixin_44498400的博客
01-04 119
单链表的存储结构 //LNode表示一个单一的结点 //*LinkList表示头指针，指向一个单链表的头结点，头结点一般为空！ typedef struct LNode { ElemType data; struct LNode *next; }LNode, *LinkList; 初始化 Status InitList(LinkList *L) { /* *L = (LNode *)malloc(sizeof(LNode)); */ //头结点的data一般为空 (*L) = new LN
数据结构——第二章.线性表
m0_53218045的博客
12-02 280
数据结构 第二章
数据结构第二章 线性表题目答案
qq_43663263的博客
05-03 5652
一、选择题 1.表长为n 的顺序存储的线性表，当在任何位置上插入或删除一个元素的概率相等时，插入一个元素所需移动元素的平均次数为( E )，删除一个元素需要移动的元素的个数为( A ) A. (n-1)/2 B .n C.n+1 D.n-1 E. n/2 F.(n+1)/2 G.(n-2)/2...
数据结构第二章-线性表（详细知识点总结）
疯子书生的博客
11-25 1万+
第二章 线性表 【考纲内容】 （一）线性表的定义和基本操作 （二）线性表的实现 顺序存储；链式存储；线性表的应用 【框架】 2.1 线性表的定义和操作 2.1.1 线性表的定义 线性表是具有相同数据类型的n（n>=0）个数据元素的有限序列，其中n为表长，当n=0时，线性表是一个空表。若用L命名线性表，则其一般表示为                &nbs
数据结构 第二章 线性表作业
weixin_41360517的博客
08-05 5103
线性表作业（共50分） 答案链接链接 一、完成下面选择题（每空2分，共14分）。 1. 顺序存储结构中数据中数据元素之间逻辑关系是由（ ）表示的，链接存储结构中的数据元素之间的逻辑关系是由（ ）表示的。 A．线性结构 B．非线性结构 C．存储位置 D．指针 2. 线性表是（ ）。 A．一个有限序列，可以为空 ...
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
热门推荐
chongyang_的博客
11-07 26万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
数据结构：第二章 线性表修改(引用版).ppt
06-10
线性表是一种基本的数据结构，它的特点是数据元素之间存在一对一的线性关系，即每个元素除了第一个和最后一个外，都有且仅有一个直接前驱和一个直接后继。 线性表的类型定义： 线性表可以被定义为一个包含n个数据...
数据结构第二章 线性表.doc
09-30
线性表是数据结构中基础且重要的概念，它由有限个数据元素（属于同一数据类型）组成，这些元素之间存在一对一的线性关系。线性表可以分为两种主要的存储结构：顺序表和链表。 1. **顺序表**： 顺序表是通过一维...
数据结构课后习题答案第二章 线性表.docx
最新发布
11-12
线性表是计算机科学中一种基础的数据结构，用于组织和管理具有线性关系的数据元素序列。本章主要探讨了线性表的两种常见存储结构——顺序表和链表，以及它们各自的特点和适用场景。 首先，头指针、头结点和首元结点...
数据结构考研讲义 第二章 线性表.pdf
08-31
【线性表】是数据结构中的基础概念，它是由相同数据类型的 n 个元素构成的有限序列，可以表示为 (a1, a2, ..., ai-1, ai, ai+1, ..., an)，n 称为表的长度，n=0 时为空表。线性表的数据元素之间存在一对一的关系，即...
数据结构课后习题 - 第二章问题.pptx
12-05
本章的习题主要涉及到线性表的处理，特别是单链表的操作，包括元素的删除和链表的逆置，以及一个涉及链表分割的练习。下面我们将详细讨论这些知识点。 首先，我们来看习题2.19，这是一个关于在线性表中删除特定范围...
数据结构第二章作业答案参考（C语言）
02-05
1. 顺序存储结构中数据中数据元素之间逻辑关系是由（ ）表示的，链接存储结构中的数据元素之间的逻辑关系是由（ ）表示的。 A．线性结构 B．非线性结构 C．存储位置 D．指针 2. 线性表是（ ）。 A．一个有限序列，...
数据结构（C语言版） 第二章 线性表 知识梳理+作业习题详解1
08-03
线性表是数据结构中的基础概念，它由若干个数据元素组成，这些元素在逻辑上具有线性关系，即每个元素要么是第一个，要么有唯一的前驱，要么是最后一个，要么有唯一的后继。线性表可以采用两种主要的存储方式：顺序...
数据结构全部课件\\第二章线性表1_链表.ppt
08-15
线性表是一种基础且重要的数据结构，它是由n（n>=0）个数据元素组成的有限序列。线性表的特点在于每个元素都有且仅有一个直接前驱和一个直接后继，除了首元素（头元素）没有前驱，尾元素没有后继。例如，英文字母表...
数据结构第二章-线性表详解
"本章小结-数据结构第二章，主要涵盖了线性表的基本概念、顺序存储和链式存储的特点，以及单链表、双向链表和循环链表的介绍。" 在数据结构中，线性表是一个重要的基础概念，它是由n个数据元素构成的有限序列，每个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值