24考研数据结构-线性表3

最新推荐文章于 2024-10-10 22:30:08 发布
最新推荐文章于 2024-10-10 22:30:08 发布
阅读量119 收藏
点赞数
分类专栏： # 数据结构 考研 文章标签： 考研 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56091756/article/details/131915267
版权

目录

2.4 线性表的链式表示

2.4.0 引入的原因

在这里插入图片描述

2.4.1 单链表的定义

定义： 线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。

typedef struct LNode{//定义单链表结点类型
    ElemType data; //数据域
    struct LNode *next;//指针域
}LNode, *LinkList;

可以利用typedef关键字——数据类型重命名：type<数据类型><别名>

等价：

struct LNode{//定义单链表结点类型
    ElemType data; //数据域
    struct LNode *next;//指针域
}
typedef struct LNode LNode；
typedef struct LNode *LinkList;

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

2.4.2 单链表的两种实现形式

2.4.2.1 不带头结点的单链表
typedef struct LNode{  //数据结构是存有本身的数据以及下一个的地址
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//初始化一个空的单链表
bool InitList(LinkList &L){  //注意用引用 &
    L = NULL; //空表，暂时还没有任何结点；直接指定一个空指针当作头指针，
    //这个空指针指向的下一个元素就应该是有数据的第一个节点
    return true;
}

void test(){
    LinkList L;  //声明一个指向单链表的指针: 头指针
    //初始化一个空表
    InitList(L);
    //...
}

//判断单链表是否为空
bool Empty(LinkList L){
    if (L == NULL)
        return true;
    else
        return false;
}
2.4.2.2 带头结点的单链表

头指针：开辟空间返回的指向单链表的起始物理地址的指针，仅是一个指针

不带头节点的单链表的头指针指向的头节点有数据；
带头节点的单链表的头指针指向的头节点是没有数据的

头结点：代表链表上头指针指向的第一个结点。

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

//初始化一个单链表（带头结点）
bool InitList(LinkList &L){  
    L = (LNode*) malloc(sizeof(LNode));  //头指针指向的结点——分配一个头结点
    //（不存储数据）返回的LNode*赋值给头指针，指向的就是第一个节点头节点，头节点为空。
    if (L == NULL)          //内存不足，分配失败
        return false;
    L -> next = NULL;       //头结点之后暂时还没有结点
    return true;
}

void test(){
    LinkList L;  //声明一个指向单链表的指针: 头指针
    //初始化一个空表
    InitList(L);
    //...
}

//判断单链表是否为空（带头结点）
bool Empty(LinkList L){
    if (L->next == NULL)
        return true;
    else
        return false;
}
2.4.2.3知识回顾与重要考点

在这里插入图片描述
带头结点和不带头结点的比较：
不带头结点：写代码麻烦！对第一个数据节点和后续数据节点的处理需要用不同的代码逻辑，对空表和非空表的处理也需要用不同的代码逻辑; 头指针指向的结点用于存放实际数据;
带头结点：头指针指向的头结点不存放实际数据,头结点指向的下一个结点才存放实际数据;

2.4.3.1 带头结点的单链表按位序插入节点

ListInsert(&L, i, e) ;在表L中的第i个位置上插入指定元素e = 找到第i-1个结点(前驱结点)，将新结点插入其后；其中头结点可以看作第0个结点，故i=1时也适用。

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

//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L, int i, ElemType e){  
    //判断i的合法性, i是位序号(从1开始)
    if(i<1)
        return False;
    
    LNode *p;       //指针p指向当前扫描到的结点 
    int j=0;        //当前p指向的是第几个结点，=0则表示目前指向头节点，链表下标从1开始
    p = L;          //L指向头结点，头结点是第0个结点（不存数据）

    //循环找到第i-1个结点，因为要修改插入节点位子的前一个节点的指针
    while(p!=NULL && j<i-1){     //如果i>lengh, p最后会等于NULL
        p = p->next;             //p指向下一个结点
        j++;
    }

    if (p==NULL)                 //i值不合法
        return false;
    
    //在第i-1个结点后插入新结点
    LNode *s = (LNode *)malloc(sizeof(LNode)); //申请一个结点空间用于存放新的节点的数据
    s->data = e;  //让新的节点的数据为e
    s->next = p->next;  //让新的节点的
    p->next = s;                 //将结点s连到p后,后两步千万不能颠倒qwq

    return true;
}
注意:
1.j = 0,是头节点的位置，这个0是方便编程的，链表的下标是从1开始
2.需要找到的位置是i-1，因为需要修改插入节点位置的上一个LNode的指针，让它指向插入节点
3.倘若最后查找出来的p指针指向null，则说明i的值不合法，因为第i-1个元素已经是null了，超过了最后一个节点，指向了null
4.最重要的LNode的指针逻辑：首先申请一个新的LNode地址指针，指向新分配的空间；设置这个LNode的数据值为e；新分配的LNode的下一个位置指向p的下一个位置（绿色线）；再将当前的p指针的下一位指向新分配的LNode（黄色线）。
5.倘若绿色黄色颠倒，则会产生LNode指向自己而不是原本的p指向的后边的链表，后边的链表就会丢失。

在这里插入图片描述

2.4.3.2 单链表的插入节点的时间复杂度

最好情况：插入表头 O（1）
最坏情况：插入表尾O（n）
平均时间复杂度：O（n）
插入每个位置（n+1个位置）的概率都是 1 n + 1 \frac{1}{n+1} n+11​， ( 1 + n ) n 2 ∗ 1 n + 1 = n 2 \frac{(1+n)n}{2}*\frac{1}{n+1} =\frac{n}{2} 2(1+n)n​∗n+11​=2n​

2.4.3.3 不带头结点的单链表的插入节点

ListInsert(&L, i, e) :在表L中的第i个位置上插入指定元素e = 找到第i-1个结点(前驱结点)，将新结点插入其后; 因为不带头结点，所以不存在“第0个”结点，因此！i=1 时，需要特殊处理——插入(删除)第1个元素时，需要更改头指针L;

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

bool ListInsert(LinkList &L, int i, ElemType e){
    if(i<1)
        return false;
    
    //插入到第1个位置时的操作有所不同！
    if(i==1){
        LNode *s = (LNode *)malloc(size of(LNode));
        s->data =e;
        s->next =L;
        L=s;          //头指针指向新结点
        return true;
    }

    //i>1的情况与带头结点一样！唯一区别是j的初始值为1
    LNode *p;       
    int j=1;        
    p = L;          //L指向第一个结点（存数据）

    //循环找到第i-1个结点
    while(p!=NULL && j<i-1){     //如果i>lengh, p最后会等于NULL
        p = p->next;             //p指向下一个结点
        j++;
    }

    if (p==NULL)                 //i值不合法
        return false;
    
    //在第i-1个结点后插入新结点
    LNode *s = (LNode *)malloc(sizeof(LNode)); //申请一个结点
    s->data = e;
    s->next = p->next;
    p->next = s;          
    return true;

}
注意:
1.最重要的LNode的i = 1的指针逻辑：首先申请一个新的LNode地址指针，指向新分配的空间；设置这个LNode的数据值为e；新分配的LNode的下一个位置指向头指针L指向的位置（s->next =L; 绿色线）；再将当前的头指针L指向新分配的LNode（L=s; 黄色线）。
2.不带头节点插入删除i=1的节点，需要修改头指针，所以不带头指针需要考虑对i=1操作的情况会比较麻烦。
3.此时对于定位的j，需要设置初始值为1，而不是带头节点的0。
4.若i不为1，则操作都一样
2.4.3.4 不带头结点的单链表的插入节点的时间复杂度

同上

最好情况：插入表头 O（1）
最坏情况：插入表尾O（n）
平均时间复杂度：O（n）
插入每个位置（n+1个位置）的概率都是 1 n + 1 \frac{1}{n+1} n+11​， ( 1 + n ) n 2 ∗ 1 n + 1 = n 2 \frac{(1+n)n}{2}*\frac{1}{n+1} =\frac{n}{2} 2(1+n)n​∗n+11​=2n​

2.4.3.5 指定节点的后插操作

InsertNextNode(LNode *p, ElemType e): 给定一个结点p，在其之后插入元素e; 根据单链表的链接指针只能往后查找，故给定一个结点p，那么p之后的结点我们都可知，但是p结点之前的结点无法得知;

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

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保存数据元素e 
    s->next = p->next;
    p->next = s;          //将结点s连到p之后

    return true;
}                         //平均时间复杂度 = O(1)


//有了后插操作，那么在第i个位置上插入指定元素e的代码可以改成：
bool ListInsert(LinkList &L, int i, ElemType e){  
    if(i<1)
        return False;
    
    LNode *p;       //指针p指向当前扫描到的结点 
    int j=0;        //当前p指向的是第几个结点
    p = L;          //L指向头结点，头结点是第0个结点（不存数据）

    //循环找到第i-1个结点
    while(p!=NULL && j<i-1){     //如果i>lengh, p最后4鸟会等于NULL
        p = p->next;             //p指向下一个结点
        j++;
    }

    return InsertNextNode(p, e)
}
注意:
1.bool InsertNextNode(LNode *p, ElemType e)，后插操作判断给的指针是否是空指针；判断是否内存分配失败
2.找到第i-1个节点就可以调用这个后插函数 return InsertNextNode(p, e)
3.时间复杂度为O（1） 
    if(p==NULL){
        return false;
    }

    LNode *s = (LNode *)malloc(sizeof(LNode));
    //某些情况下分配失败，比如内存不足
    if(s==NULL)
        return false;
2.4.3.6 指定节点的前插操作

InsertPriorNode(LNode *p, ElenType e) 思想：设待插入结点是s，将s插入到p的前面。我们仍然可以将s插入到*p的后面。然后将p->data与s->data交换，这样既能满足了逻辑关系，又能是的时间复杂度为O(1).

  1. 传入头指针，从头开始遍历寻找到指定节点前驱
    在这里插入图片描述

  2. 不传入头节点，使用交换指定节点和需要插入节点的数据，完成操作
    该方法时间复杂度为O（1)

在这里插入图片描述

//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p, ElenType e){
    if(p==NULL)
        return false;
    
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s==NULL) //内存分配失败
        return false;

    //重点来了！
    s->next = p->next;
    p->next = s;       //新结点s连到p之后
    s->data = p->data; //将p中元素复制到s
    p->data = e;       //p中元素覆盖为e

    return true；
}  //时间复杂度为O(1)
  1. 王道书上版本（传入指定节点与需要插入的节点）
bool InsertPriorNode(LNode *p, LNode *s){
    if(p==NULL || S==NULL)
        return false;
    
    s->next = p->next;
    p->next = s;  ///s连接到p
    ELemType temp = p->data;  //声明临时变量temp存储p的数据
    p->data = s->data;  //用需要插入节点的数据覆盖p中的数据
    s->data = temp;  //将临时变量赋值给s的数据部分

    return true;
}
 



ELemType temp = p->data;  //交换数据域部分，声明临时变量temp存储p的数据
2.4.3.7 按位序删除节点（带头结点）

ListDelete(&L, i, &e) : 删除操作，删除表L中第i个位置的元素，并用e返回删除元素的值;头结点视为“第0个”结点；

思路：找到第i-1个结点，将其指针指向第i+1个结点，并释放第i个结点；

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

bool ListDelete(LinkList &L, int i, ElenType &e){
    if(i<1) return false;

    LNode *p;       //指针p指向当前扫描到的结点 
    int j=0;        //当前p指向的是第几个结点
    p = L;          //L指向头结点，头结点是第0个结点（不存数据）

    //循环找到第i-1个结点
    while(p!=NULL && j<i-1){     //如果i>lengh, p最后会等于NULL
        p = p->next;             //p指向下一个结点
        j++;
    }

    if(p==NULL) 
        return false;
    if(p->next == NULL) //第i-1个结点之后已无其他结点
        return false;

    LNode *q = p->next;         //令q指向被删除的结点
    e = q->data;                //用e返回被删除元素的值
    p->next = q->next;          //将*q结点从链中“断开”
    free(q)                     //释放结点的存储空间

    return true;
}
2.4.3.8 按位序删除节点（带头结点）的时间复杂度

同上

最好情况：插入表头 O（1）
最坏情况：插入表尾O（n）
平均时间复杂度：O（n）

2.4.3.9 指定结点的删除
bool DeleteNode(LNode *p){
    if(p==NULL)
        return false;
    
    LNode *q = p->next;      //令q指向*p的后继结点
    p->data = p->next->data; //让p和后继结点交换数据域
    p->next = q->next;       //将*q结点从链中“断开”
    free(q);
    return true;
} //时间复杂度 = O(1)

倘若需要删除的是最后一个节点，则时间复杂度为O（n），因为找不到下一个节点不能跟它交换数据，再free它。只能从链表的头开始寻找到该指针的前继节点，将它指向null。

2.4.3.10 知识回顾与重要考点

在这里插入图片描述

VengaZ
关注
专栏目录
王道数据结构-线性表中顺序表的一些综合应用题 王道操作系统-PV操作综合大题总结
12-31
在本文中，我们将探讨线性表中...在考研或深入学习数据结构时，理解和掌握这些方法是非常重要的，它们有助于解决实际问题并优化程序性能。在实际编程中，还需要注意边界条件的处理和错误信息的反馈，确保代码的健壮性。
数据结构考研资料--线性表及答案
01-05
2008年5月8日 ... 写出将la 和lb两链表归并成一个结点按元素值非递减有序排列的单链表（其头指针为lc），并计算算法的 ... 【北京工业大学1997 一、1 (8分)】 （2）设有两个链表，ha为单向链表，hb为单向循环...
24考研数据结构-线性表1
VengaZ的学习博客
07-24 97
线性表的定义、基本操作、物理存储结构、特点
24考研数据结构-线性表5
VengaZ的学习博客
07-26 114
双链表与循环链表
24考研数据结构-线性表2
VengaZ的学习博客
07-24 84
顺序表的基本操作
考研数据结构-线性表
weixin_61852944的博客
10-09 356
/ 定义顺序表存放元素的数组int length;//顺序表长度}Sqlist;结构体的定义书写起来会比较麻烦，用下面方式书写，可以大大提高效率int n;}LNode;}DLNode;
考研数据结构--线性表
Maverick_曲流觞的博客
04-15 664
顺序表的定义,初始化,插入,删除,查找,输出,判空,销毁 单链表的定义,初始化,头插法,尾插法,按序号查找,按值查找,插入,删除,逆置,输出,判空,销毁 双链表的定义,初始化,头插法,尾插法,按序号查找,插入,删除,判空,打印 循环单链表,循环双链表,稀疏多项式
王道408考研数据结构-线性表-第二章
qq_55882840的博客
09-17 1429
2.1 线性表的定义2.1.1 线性表的定义线性表是具有相同数据类型的n(n≥0)个数据元素的有限序列，其中n为表长，当n=0 时线性表是一个空表。若用L命名线性表，则其一般表示为式中，a1是唯一的“第一个”数据元素，又称表头元素；an是唯一的“最后一个”数据元素，又 称表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后继(“直接前驱”和“前驱”、“直接后继”和“后继”通常被视为同义词)。
408考研-数据结构-线性表
quan_yyds的博客
03-07 927
关于线性表数组实现部分的知识和代码笔记
24考研数据结构-线性表4
VengaZ的学习博客
07-25 658
线性表的查找和逆置
计算机考研数据结构----线性表
weixin_43970560的博客
07-07 914
第二章 线性表 一、线性表的定义 线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，其一般表示为L=(a1,a2,a3,…,ai,ai+1,…,an)。 线性表的特点： 1.表中元素的个数有限。 2.表中元素具有逻辑上的顺序性，表中元素有其先后次序。 3.表中元素都是数据元素，每个元素都是单个元素。 4.表中元素的数据类型都相同，每个元素占用相同大小的存储空间。 ai是线性表中的第i个元素在线性表中的位序。 a1是唯一的第一个数据
王道考研数据结构第二讲-线性表
07-21
和我的王道考研数据结构专题中的代码对应，可以参看https://blog.csdn.net/zhangbaodan1/article/details/81142428
数据结构考研线性表
06-04
这是数据结构中C语言版部分线性表的学习记录，有关动态在我的博客里有对应。方便大家参考。
考研笔记之操作系统（四） - 文件管理
muls1的博客
10-07 873
笔记详细记录了王道考研咸鱼学长讲解的操作系统课程的难点、重点、考点。包括文件管理的简介、文件的逻辑结构、文件目录、文件的物理结构、逻辑结构VS物理结构、文件存储空间管理、文件的基本操作、文件共享、文件保护、文件系统的层次结构、文件系统的全局结构、虚拟文件系统等内容。
【操作系统考研】2进程管理（1）
Winkyyyyyy的博客
10-07 1010
820操作系统进程管理（1）
考研代码题：10.10 汉诺塔 爬楼梯 取球 猴子吃桃
最新发布
qq_62556650的博客
10-10 204
【代码】考研代码题：10.10 汉诺塔 爬楼梯 取球 猴子吃桃。
数据结构编程实践20讲(Python版)—06二叉搜索树
AnFany
10-08 1142
数据结构编程实践20讲(Python版)—06二叉搜索树
每日学习一个数据结构-树
wendao76的专栏
10-03 1157
树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。在非空树中，有且仅有一个特定的节点被称为根（root），其余节点可分为m（m>0）个互不相交的有限集T1, T2, …, Tm，其中每一个集合本身又是一棵树，并且被称为根的子树（Subtree）。访问时机：三种遍历方式的主要区别在于访问根节点的时机不同。在前序遍历中，根节点在左、右子节点之前被访问；在中序遍历中，根节点在左、右子节点之间被访问；在后序遍历中，根节点在左、右子节点之后被访问。应用场景。
数据结构-线性表、栈、队列、树、图及查找解析
"这篇文档是新东方在线考研计算机讲义的一部分，主要涵盖了数据结构中的核心概念，包括线性表、栈、队列、数组、树、二叉树、图以及查找操作。文中详细讲解了各类数据结构的定义、存储方式、操作实现以及应用实例，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

VengaZ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值