25考研数据结构复习·2.3链表.2

已于 2024-01-16 20:48:13 修改
阅读量903 收藏 27
点赞数 17
分类专栏： # 第二章 线性表 文章标签： 数据结构 链表 考研
于 2024-01-16 20:47:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Annabelle___/article/details/135634327
版权

  • 基本操作的实现

    • 插入和删除

      ❕插入、删除的代码都要会写，都重要

      • 插入

        • 按位序插入
          • 带头结点

            ListInsert(&L,i,e): 插入操作。在表L中的第i个位置上插入指定元素e。

头结点可以看作“第0个”结点 

  • 代码实现
    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 = GetElem(L,i -1);  //找到第i个结点
		LNode *p;  //指针p指向当前扫描到的结点
		int j = 0;  //当前p指向的是第几个结点
		p = L;  //L指向头结点，头结点是第0个结点（不存数据）
		//重要循环
		while(p != NULL && j < i-1){
				p = p -> next;
				j++;
		}
		if(p == NULL)  //i值不合法
				return false;
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s -> data = e;
		//以下两句代码顺序不可颠倒
		s ->next = p -> next;
		p -> next = s;  //将结点s连到p之后
		return true;  //插入成功
}

    ！分析：

    1.如果i = 1（插在表头）

最好时间复杂度：O(1)

2.如果i = 3（插在表中） 自己走一遍代码即可看懂

3.如果i = 5（插在表尾）

最坏时间复杂度：O(n)

4.如果i = 6 （i > length）

  • 不带头结点

    ListInsert(&L,i,e): 插入操作。在表L中的第i个位置上插入指定元素e。

    • 不存在“第0个”结点，因此i = 1时需要特殊处理
  • 代码实现
    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){  //插入第1个结点的操作与其他结点操作不同
				LNode *s = (LNode *)malloc(sizeof(LNode));
				s -> data = e;
				s -> next = L;
				L = s;  //头指针指向新结点
				return true;
		}
		LNode *p;  //指针p指向当前扫描到的结点
		int j = 1;  //当前p指向的是第几个结点
		p = L;  //p指向第1个结点（注意：不是头结点）
		//重要循环
		while(p != NULL && j < i-1){  //循环找到第i - 1 个结点
				p = p -> next;
				j++;
		}
		if(p == NULL)  //i值不合法
				return false;
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s -> data = e;
		//以下两句代码顺序不可颠倒
		s ->next = p -> next;
		p -> next = s;  //将结点s连到p之后
		return true;  //插入成功
}

    ！分析：

    1.如果i = 1（插在表头）

2.如果i > 1…  后续逻辑和带头结点的一样

💡 考试中带头、不带头都有可能考察，注意审题

  • 指定结点的后插操作
    typedef struct LNode{  
		ElemType data;  
		struct LNode *next;  
}LNode, *LinkList;

//后插操作：在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保存数据元素e
		s ->next = p -> next;
		p -> next = s;  //将结点s连到p之后
		return true;  
}

    时间复杂度：O(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指向的是第几个结点
		p = L;  //L指向头结点，头结点是第0个结点（不存数据）
		//重要循环
		while(p != NULL && j < i-1){
				p = p -> next;
				j++;
		}
		//优化
		return InsertNextNode(p,e);
}

      ⭐ 封装（基本操作）的好处

      避免重复代码，简介，易维护

  • 指定结点的前插操作
    • 方法1
      //前插操作：在p结点之前插入元素e
//传入头指针
bool InsertPriorNode(LinkList L, LNode *p, ElemType e)

      时间复杂度：O(n)

  • 方法2
    //前插操作：在p结点之前插入元素e
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;  //新结点s连到p之后
		s -> data = p -> data;  //将p中元素复制到s中
		p -> data = e;  //p中元素覆盖为e
		return true;  
}

    时间复杂度：O(1)

  • 删除

    • 按位序删除（带头结点）

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

（找到第i -1 个结点，将其指针指向第i + 1个结点，并释放第i个结点 ）

  • 代码实现
    typedef struct LNode{  
		ElemType data;  
		struct LNode *next;  
}LNode, *LinkList;

bool ListDelete(LinkList &L,int i,ElemType &e){
		if(i < 1)
				return false;
		//优化
		//LNode *p = GetElem(L,i -1);  //找到第i个结点
		LNode *p;  //指针p指向当前扫描到的结点
		int j = 0;  //当前p指向的是第几个结点
		p = L;  //L指向头结点，头结点是第0个结点（不存数据）
		//重要循环
		while(p != NULL && j < i-1){  //循环找到第i - 1个结点
				p = p -> next;
				j++;
		}
		if(p == NULL)  //i值不合法
				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;  //插入成功
}

    ！ 分析：

    1.如果i = 4…

最坏、平均时间复杂度：O(n)

最好时间复杂度： O(1)

 ❔如果不带头结点，删除第1个元素，是否需要特殊处理？

❕需要特殊处理，除第一个元素的其他元素要删除需要找到该元素的前一个元素，保证链不断 而第一个元素只要修改L的指向

  • 指定结点的删除
    //删除指定结点p
bool DeleteNode(LNode *p)
    • 删除结点p，需要修改其前驱结点的next指针

  • 方法1：传入头指针，循环寻找p的前驱结点

  • 方法2：偷天换日（类似于结点前插的实现）

    //删除指定结点p
bool DeleteNode(LNode *p){
		if(p == NULL)
				return false;
		LNode *q = p -> next;  //令q指向*p的后继结点
		p -> data = p -> next -> data;  //和后继节点交换数据域
		p -> next = q -> next;  //将*q结点从链中“断开” 可能是指向一个结点，也可能是指向NULL
		free(q);  //释放后继结点的内存空间
		return true;
}

    时间复杂度：O(1)

    ❔ 如果p是最后一个结点

    ❕ 只能从表头开始依次寻找p的前驱，时间复杂度O(n)

    查找

    • 按位查找

      ✅只探讨“带头结点”的情况

      GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值。

    • 代码实现

//按位查找，返回第i个元素（带头结点）
LNode * GetElem(LinkList L,int i){
		if(i < 0)
				return NULL;
		LNode *p;  //指针p指向当前扫描到的结点
		int j = 0;  //当前p指向的是第几个结点
		p = L;  //L指向头结点，头结点是第0个结点（不存数据）
		while(p != NULL && j < i){  //循环找到第i个结点
				p = p -> next;
				j++;
		}
		return p;
}

边界情况：1.如果i = 0  2.如果i = 8

普通情况：如果i = 3

平均时间复杂度：O(n)

  • 按值查找

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

    • 代码实现
      //按值查找，找到数据域==e 的特点
//注释：假设本例中ElemType是int
LNode * LocateElem(LinkList L,ElemType e){
		LNode *p = L -> next;
		//从第1个结点开始查找数据域为e的结点
		while (p != NULL && p -> data != e)
				p = p -> next;
		return p;  //找到后返回该结点指针，否则返回NULL
}

      （头指针 → 5 → 8 → 10 → 2 → NULL）

    • 能找到的情况：如果e = 8

    • 不能找到的情况：如果e = 6

      平均时间复杂度：O(n)

  • 求表的长度

    //求表的长度
int Length(LinkList L){
		int len = 0;  //统计表长
		LNode *p = L;
		while(p -> next != NULL){
				p = p -> next;
				len++;
		}
		return len;
}

    时间复杂度：O(n)

总结： 

 

  • 建立

    ❔ 如果给你很多个数据元素（ElemType），要把他们存放到一个单链表里，怎么做？

    ❕step1：初始化一个单链表。 step2：每次取一个数据元素，插入到表尾/表头

    注：探讨带头结点的情况👇

  • 尾插法

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

//初始化一个单链表（带头结点）
bool InitList(LinkList &L){
		L = (LNode *) malloc(sizeif(LNode));  //分配一个头节点
		if (L == NULL)  //内存不足，分配失败
				return false;
		L -> next = NULL;  //头节点之后暂时还没有结点
		return true;
}

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

//第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个结点（不存数据）
		//每次都从头开始之后遍历，时间复杂度为O(n²)
		**while(p != NULL && j < i-1){  //循环找到第i - 1个结点
				p = p -> next;
				j++;
		}**
		if(p == NULL)  //i值不合法
				return false;
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s -> data = e;
		s ->next = p -> next;
		p -> next = s;  //将结点s连到p之后
		return true;  //插入成功
}

    • 初始化单链表

    • 设置变量length记录链表长度

    • While循环{

      每次取一个数据元素e;

      ListInsert(L,length + 1,e)插到尾部;

      length++;  }

    因为while循环时间复杂度O(n²)太高，故可以建立一个尾指针👇

    LinkList List_TailInsert(LinkList &L){  //正向建立单链表
		int x;  //设ElemType为整型
		L = (LinkList)malloc(sizeof(LNode));  //建立头结点
		LNode *s,*r = L;  //r为表尾指针
		scanf("%d",&x);  //输入结点的值
		while(x != 9999){  //输入9999表示结束
				**s = (LNode *)malloc(sizeof(LNode));
				s -> data = x;
				r -> next = s;**
				r = s;  //r指向新的表尾结点 永远保持r指向最后一个结点
				scanf("%d",&x);
		}
		r -> next = NULL;  //尾结点指针置空
		return L;
}

    时间复杂度：O(n)

💡 注意设置一个指向表尾结点的指针

  • 头插法

    💡 核心：对头结点的后插操作

    • 初始化单链表

    • while 循环{

      每次取一个数据元素e;

      InsertNextNode(L,e);

      }

    LinkList List_HeadInsert(LinkList &L){  //逆向建立单链表
		LNode *s;
		int x;  
		L = (LinkList)malloc(sizeof(LNode));  //建立头结点
		//只要是初始化但列联表，都先把头指针指向NULL （防止指向脏数据）
		**L -> next = NULL;  //初始为空链表**
		scanf("%d",&x);  //输入结点的值
		while(x != 9999){  //输入9999表示结束
				s = (LNode *)malloc(sizeof(LNode));  //创建新结点
				s -> data = x;
				r -> next = L -> next;
				L -> next = s;  //将新结点插入表中，L为头指针
				scanf("%d",&x);
		}
		return L;
}

    ❗ 重要应用——链表的逆置

  • 💡 核心就是初始化操作、指定结点的后插操作

Annabelle.02
关注
  • 17
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
数据结构-使用javascript讲解数据结构之链表.zip
02-12
本资料包“数据结构-使用javascript讲解数据结构之链表.zip”将深入探讨链表的概念、实现以及其在JavaScript中的应用。 链表不同于数组，数组是连续的内存空间，而链表的元素在内存中是非连续存储的。每个元素称为...
25考研数据结构复习·2.3链表.1
Annabelle___的博客
01-15 775
struct LNode{ //结点；定义单链表结点类型//数据域；每个结点存放一个数据元素//指针域；指针指向下一个结点//增加一个新的结点：在内存中申请一个结点所需空间，并用指针p指向这个结点//优化typedef 关键字 —— 数据类型重命名typedef <数据类型><别名>typedef struct LNode{ //定义单链表结点类型//每个结点村南方一个数据元素//指针指向下一个结点struct LNode{ //定义单链表结点类型//每个结点存放一个数据元素。
25考研数据结构复习·2.3链表.3
Annabelle___的博客
01-17 793
用数组的方式实现的链表分配一整片连续的内存空间，各个结点集中安置。每个数据元素4B，每个游标4B（每个结点共8B）设起始地址为addra₁的存放地址为addr+ 8*2//方法1#define MaxSize 10 //静态链表的最大长度struct Node{ //静态链表结构类型的定义//存储数据元素int next;//下一个元素的数组下标//可用SLinkList定义“一个长度为MaxSize的Node型数组”//数组a作为静态链表//...后续代码等价于👇。
王道考研数据结构--2.1.单链表
我是个好人呀，????
06-21 709
日期：2023.6.21书籍：2024年数据结构考研复习指导（王道考研系列）内容：单链表的实现，结构体定义，初始化，创建新结点，头插和尾插，查询，按位序插入，删除指定节点，输出单链表//C语言自定义bool操作/*单链表结构体定义*/typedef struct LNode //定义单链表结点类型//每个结点存放一个数据元素//指针指向下一节点LinkList L;//声明一个指向单链表第一个结点的指针,这种方法代码可读性更强，强调单链表等价于：LNode *L;
【考研复习】24王道数据结构课后习题代码｜2.3线性表的链式表示
m0_52427832的博客
08-05 1237
删除结点：1、2、4就地逆置：5、合并链表分解链表：10、11、去除重复元素：12、并集：14、15循环链表：17、18、19、20头插法、尾插法重点基础必掌握。判断是否有环：21。
【数据结构|单循环链表】单循环链表大部分基本操作总结（严蔚敏数据结构）
爱喝冰红茶的方舟的博客
04-27 1304
本文基本涵盖了单循环链表的大部分基本操作，与严蔚敏数据结构内容大致贴合，且大部分函数取名结合STL，可结合来学习，可直接最后跳转完整代码复制，代码运行没问题（截图省了）有问题欢迎交流。
【数据结构复习之路】查找（严蔚敏版）万字详解
m0_74215326的博客
12-30 1544
int key;对二叉排序树进行中序遍历，可以得到一个递增的有序序列。以上讨论的表示查找表的各种结构的共同特点：记录在表中的位置和它的关键字之间不存在一个确定的关系，并且查找过程是：给定值依次和关键字集合中各关键字进行比较。散列表（Hash Table），又称为哈希表。是一种数据结构，特点：数据元素的关键字与其存储地址直接相关。记录的关键字与记录在表中的存储位置之间存在一种对应（函数）关系。若记录的关键字为 key，记录在表中的位置（称为哈希地址为f。
数据结构——链表（一）（2022考研）
weixin_45393822的博客
12-14 328
链表——单链表 #include<stdlib.h> #include<stdio.h> #define Elemtype int typedef struct LNode{ Elemtype data; struct LNode *next; }LNode,*LinkList; void InitLink(LinkList &L) { L= (LNode*)malloc(sizeof (LNode)); L->next=NULL; }
考研408复习笔记—— 数据结构（四）
池子的学习分享
09-22 930
考研408复习笔记（四）—— 数据结构（四）前篇跳转二、线性表（三）2.4.2 双链表2.4.2.1 双链表的初始化2.4.2.2 双链表的插入2.4.2.3 双链表的插入2.4.3 循环链表2.4.4 静态链表 本文中使用图片，来对微信公众号【研者荣耀】中相关课程的学习 若发布的内容有什么错误，欢迎留言探讨。 前篇跳转 考研408复习笔记（三）—— 数据结构（三） 二、线性表（三） 2.4.2 双链表 双链表，同样是链式存储的结构，与单链表，只能一个方向进行遍历不同，它存储了两个指针域，用于存放前后两个结
PHP数据结构-链表的相关逻辑操作
硬核项目经理
04-08 142
链表的相关逻辑操作链表的操作相对顺序表（数组）来说就复杂了许多。因为 PHP 确实已经为我们解决了很多数组操作上的问题，所以我们可以很方便的操作数组，也就不用为数组定义很多的逻辑操作。比如...
数据结构复习题090612.doc
12-06
数据结构复习题090612.doc 数据结构是计算机科学中的一门基础学科，涉及到数据的存储、管理和操作。数据结构可以从逻辑上分为线性结构和非线性结构两大类。线性结构包括数组、链表、栈、队列等，而非线性结构包括树...
最新经典考研数据结构复习资料六.doc
06-13
数据结构是计算机科学中的核心课程，它涉及到如何有效地组织和管理数据，以便高效地进行存储、检索和处理。...这些内容是计算机科学考研中数据结构部分的重要复习资料，涵盖了数据结构的基础理论和实践应用。
数据结构中的链表.docx
03-20
链表作为数据结构的一种，是理解程序设计的重要工具。在本文中，我们将深入探讨链表的特性、种类以及如何在C语言中实现链表。 首先，链表是一种线性结构，它不同于数组那样顺序且连续地存储数据元素。链表中的每个...
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 673
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 581
递归算法，爬楼梯等解法
二分查找和斐波那契查找
最新发布
weixin_50960004的博客
07-13 179
表面上看，后一调整存在风险，此时只能确定切分点arr[mid]＞target ，“贸然”地将arr[mi]排除在进一步的查找范围之外，似乎可能因遗漏这些元素，而导致本应成功的查找以失败告终。也就是说，无论朝哪个方向深入，都只需做1次元素的大小比较，其二，统一沿两个方向深入所需要执行的比较次数，比如都统一为一次。在有序向量中的查找，遇到重复的元素时会返回秩最大的那个，上述查找无法实现这个功能，因此加以改进。所以这样的话，想进入左半区间，进行一次比较，想进入右半区间，会进行两次比较，右侧比较会多。
数据结构day6链式队列
picians的博客
07-10 559
主程序dequeue(Q);Q=NULL;return 0;源程序free(Q);Q=NULL;H->len=0;Q->head=H;Q->tail=H;return Q;return -1;return new;return;return;=NULL)
考研复习知识笔记-数据结构
04-16
已上岸 复习期间的笔记，包括知识梳理和一些经典题目，可供借鉴

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Annabelle.02

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

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

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

打赏作者

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

抵扣说明：

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

余额充值