【数据结构】单链表的相关操作--创建-插入-删除-查找

最新推荐文章于 2023-07-01 14:30:04 发布
最新推荐文章于 2023-07-01 14:30:04 发布
阅读量1.4k 收藏 5
点赞数 3
分类专栏： # 数据结构 理论通识基础 文章标签： 指针 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44321600/article/details/107552230
版权

文章目录

单链表的相关操作

单链表的创建
  • 关于带头结点与不带头结点，不带头结点表示指针指向的第一个结点就是要存放数据的结点，而带头结点表示指针指向的第一个结点内数据域不存任何数据，其指向的下一个结点才是存放数据的第一个结点。两者看似无区别，实际上区别很大：
/*不带头结点*/
typedef struct LNode { //定义单链表结点类型 
	ElemType data;	//每个结点存放一个数据元素 
	struct LNode *next;	//指针指向下一个结点 
}LNode,*LinkList;
//初始化一个空的单链表
bool InitLink(LinkList &L) {
	L = NULL;	//空表，暂时没有任何结点 
	return true;
} 
//判断单链表是否为空
bool Empty(LinkList L) {
	if(L == NULL) {
		return true;
	}else {
		return false;
	}
} 
void test01() {
	LinkList L;	//声明一个指向单链表的指针 
	InitLink(L);	//初始一个空表 
} 

/*带头结点*/
typedef struct LNode { //定义单链表结点类型 
	ElemType data;	//每个结点存放一个数据元素 
	struct LNode *next;	//指针指向下一个结点 
}LNode,*LinkList;	//强调为结点和强调为单链表 
//初始化一个空的单链表
bool InitLink(LinkList &L) {
	L = (LNode *)malloc(sizeof(LNode));	//分配一个头结点
	if(L == NULL) {	//内存不足，分配失败 
		return false; 
	}
	L->next = NULL;	//头结点之后暂时还没有结点 
	return true;
} 
//判断单链表是否为空
bool Empty(LinkList L) {
	if(L->next == NULL) {
		return true;
	}else {
		return false;
	}
}
void test02() {
	LinkList L;	//声明一个指向单链表的指针 
	InitLink(L);	//初始一个空表 
}
单链表的插入
按位序插入
  • 对于带头结点插入的分析：
    1. i=1(插在表头)
      1. 程序自上而下执行；
      2. 执行到while循环时，不满足 j<i-1 的条件，不执行循环；
      3. 实现在表头位置插入一个新元素结点；
      4. 最好时间复杂度：O(1)
    2. i=m(m<链表长度，插在表中)
      1. 程序自上而下执行；
      2. 执行到while循环时，直到找到要插入位置的前一个位置结点，否则循环继续执行；
      3. 实现在表中位置插入一个新元素结点；
    3. i=n(插在表尾)
      1. 程序自上而下执行；
      2. 执行到while循环时，直到找到要插入位置的前一个位置结点，否则循环继续执行，此时找到当前链表的最后一个结点；
      3. 实现在表尾位置插入一个新元素结点；
      4. 最坏时间复杂度：O(n)
    4. i=n+1(大于表长)
      1. 程序自上而下执行；
      2. 执行到while循环时，跳出条件不再是因为找到了位置，而是因为此时指针指向了NULL；
      3. 执行if条件判断，发现i-1个结点位置不存在，即i值不合法，无法找到位置就无法插入新元素结点，故直接返回，插入失败；
//在第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) {	//循环找到第 i-1 个结点 
		p = p->next;
		j ++;
	}
	//封装后
	//LNode *p = GetElem(L, i-1); //找到第 i-1 个结点
	
	//未封装
	if(p == NULL) {		//i值不合法 
		return false;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;	//将结点s连到P之后 
	p->next = s;		//插入成功 
	return true;
	//封装后
	//return InsertNextNode(p, e);
}

注意：进行插入时的指针指向顺序不可变，必须先执行s->next = p->next将插入结点与其插入后的后继结点相关联，再执行p->next = s将插入结点与其前驱结点相关联。若顺序颠倒，则会使新插入结点的next指针指向自己，而使插入位置之后的数据全部丢失。

  • 对于不带头结点插入的分析：
    1. i=1(插在表头)
      1. 程序自上而下执行；
      2. 插入位置为第一个位置时，需要单列出来，并且需要更改头指针L；
    2. 其余分析与带头结点的分析类似
//在第i个位置插入元素e 
/*不带头结点*/ 

bool ListInsert(LinkList &L, int i, ElemType e) {
	if(i < 1) {
		return false;
	}
	if(i == 1) {
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;	//头结点指向新结点 
		return true;
	}
	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;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;	//将结点s连到P之后 
	p->next = s;		//插入成功 
	return true;
	//封装后
	//return InsertNextNode(p, e);
}

结论：不带头结点写代码更加不方便，更建议使用带头结点的方式

指定结点的后插操作
  • 由于单链表指针是向后的，所以某位置之前的元素结点为未知区域，而某位置之后的元素结点为可知区域
//后插操作：在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)
指定结点的前插操作
  • 方式一：在原本后插操作的参数基础上，传入头指针，循环查找p的前驱q，再对q进行后插法，但有可能只进行局部操作，无法获取到他的头指针信息
    • 时间复杂度：O(n)
  • 方式二：偷天换日：在指定位置后插入一个新的元素结点，将指定位置的数据值赋值到新插入的元素结点上，再将需要插入的元素数据对原本位置上的元素数据值进行覆盖
    • 时间复杂度：O(1)
//前插操作：在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->next = p->next;
	p->next = s;		//将结点s连接到p之后 
	s->data = p->data;	//将p中元素复制到s中 
	p->data = e;		//p中元素覆盖为e 
	return true; 
}
单链表的删除
按位序删除
  • 方式：传入链表的头结点，找到所要删除结点的前驱结点再进行删除
    • 最坏、平均时间复杂度：O(n)
    • 最好时间复杂度：O(1)
bool ListDelete(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) {	//循环找到第 i-1 个结点 
		p = p->next;
		j ++;
	}
	//封装后
	//LNode *p = GetElem(L, i-1); //找到第 i-1 个结点
	
	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;			//删除成功 
}
指定结点的删除
  • 方式一：传入头指针，循环寻找p的前驱结点，再进行删除
    • 时间复杂度：O(n)
  • 方式二：偷天换日
    • 时间复杂度：O(1)
//删除指定结点p
bool DeleteNode(LNode *p) {
	if(p == NULL) {	//i值不合法 
		return false;
	}
	LNode *q = p->next;		//令q指向被删除结点 
	p->data = p->next->data;//和后继结点交换数据域 
	p->next = q->next;		//将*q结点从链中断开 
	free(q);				//释放结点的存储空间 
	return true;			//删除成功 
}

极限情况：若要删除的p恰好是最后一个结点，则方式二在执行到p->data = p->next->data会出现空指针错误，所以此方式不适用，只能使用方式一从表头开始依次寻找p的前驱可保证适用所有情况

单链表的查找
按位查找
  • 分析：
    1. 正常情况下找到第i结点的数据并返回
    2. 不正常情况，若i<0则返回false；若想要查找的位置i大于表长度，则while因为p==NULL而跳出循环，最终返回null
    3. 只需判断返回值即可知道此次是否查找到相应位置数据元素
  • 时间复杂度：O(n)
LNode * GetElem(LinkList L, int i) {
	if(i < 0) {
		return false;
	}
	LNode *p;	//指针P指向当前扫描到的结点 
	int j = 0;	//当前p指向的是第几个结点 
	p = L;		//L指向头结点，头结点是第0个结点(不存数据) 
	while(p!=NULL && j<i) {	//循环找到第i个结点 
		p = p->next;
		j ++;
	}
	return p;
}
按值查找
  • 平均时间复杂度：O(n)
LNode * LocatElem(LinkList L, ElemType e) {
	LNode *p = L->next;
	//从第1个结点开始查找数据域为e的结点 
	while(p!=NULL && p->data!=e) {
		p = p->next;
	}
	return p;	//找到后返回该结点指针，否则返回NULL 
}
  • 求表的长度
    • 时间复杂度：O(n)
int Length(LinkList L) {
	int len = 0;    //统计表长
	LNode *p = L;
	while(p->next != NULL) {
	    p = p->next;
	    len ++;
	}
	return len;
}
  • 带头结点和不带头结点的逻辑区别
    • 普遍性(高内聚)：
      • 对于带头结点的单链表来说，链表的每一个含数据的结点都拥有唯一的后继和唯一的前驱，结构更相似严谨，之后设计的算法执行的操作更具有普遍性；
      • 而对于不带头结点的单链表来说，第一个结点不具有唯一前驱，整体结构与其余结点结构就有相对性的差异，之后设计的算法以及操作就需要将其单列出来讨论，增加代码长度与复杂性；
  • 带头结点和不带头结点的代码区别
    • 对于带头结点的单链表来说，由于各结点逻辑上结构都是一样的，故在实现功能时，代码较为固定；
    • 对于不带头结点的单链表来说，需要将第一个结点与其余结点分开讨论，增加代码的复杂性，代码更长更复杂
秃头仔仔
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构（C语言版）综合实践集合运算
04-01
题目： 7. 集合运算 (单循环链表) 1.问题描述： 设有两个带头结点的单循环链表存储的集合A、B，其元素类型为字符或者整形，且以非递减方式存储，其头结点分别为ha、hb。要求下面各问题中的结果集合同样以非递减方式存储，结果集合不影响原集合。 2.实现要求： ⑶ 编写集合元素测试函数IN_SET，如果元素已经在集合中返回0，否则返回1； ⑷ 编写集合元素输入并插入到单链表中的函数INSERT_SET，保证所输入的集合中的元素是唯一且以非递减方式存储在单循环链表中； ⑶ 编写求集合A、B的交C=A∩B的函数，并输出集合C的元素； ⑷ 编写求集合A、B的并D=A∪B的函数，并输出集合D的元素； ⑸ 求集合A与B的对称差E=(A-B)∪(B-A) 的函数，并输出集合D的元素； ⑹ 设计一个菜单，具有输入集合元素、求集合A、B的交C、求集合A、B的并D、求集合A与B的对称差E、退出等基本的功能。 3.测试数据：字符型和整形由同学们自定，但集合A、B的元素个数不得少于15个。
单链表上基本操作的实现——建立，插入，查找，删除，表长。
qq_45965736的博客
09-11 9208
本文是对单链表的基本操作的学习——包括单链表的建立，删除，插入，查找，等等操作。有些操作好将带头结点单链表和不带头结点单链表均都实现了代码复现！值得一看！
循环单链表的基本操作
qq_62949330的博客
10-28 2693
第一关：循环单链表的初始化、插入及输出操作； 第二关：循环单链表的删除操作； 第三关：两个循环单链表的合并操作。
单链表的插入算法
weixin_63381305的博客
09-19 1688
单链表上的基础操作之插入算法，请将函数int InsertElem( LinkList *head, int i, ElemType e)，其中i为要插入元素的位序，插入位序的合法范围为1-6，e为要插入元素，函数返回值为操作成功（OK）与否（ERROR）
C语言：单链表的循环添加、插入操作，直到不在插入为止
yzh2776680982的博客
02-24 2289
目录 老规矩，先看结果： 代码分析： 第一步：声明 第二步：输入函数 第三步：添加函数 第四步：输出函数 第五步：主函数 完整的代码： 老规矩，先看结果： 代码分析： 第一步：声明 #include<stdio.h> #include<stdlib.h> struct student //声明结构体类型 { int num; float score; struct student *next; }; int n; //全局...
单链表的建立、插入节点、删除节点、逆序、查找等等
05-08
单链表的建立、插入节点、删除节点、逆序、查找等等，希望了可以给你们带来帮助
链表基础操作(创建、查找、删除、插入、排序)
qq_55880219的博客
07-18 2141
链表基础操作(创建、查找、删除、插入、排序) 链表是一种在物理上非连续、非顺序的数据结构，由若干个节点组成。（本文以单向链表为例）
数据结构单链表：指定结点的前插、后插操作
qq_45562742的博客
08-10 3636
指定结点的前插操作 typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; //在p结点之前插入元素e bool InsertPriorNode(LNode *p, int e){ if(p==NULL) return false; LNode *s = (LNode *)malloc(sizeof(LNode)); if(s==NULL)
数据结构----单链表的创建及相关操作
2201_75619538的博客
07-01 958
链表的介绍，创建，遍历，查找，插入和删除详细操作和具体代码实现
单链表的创建，查找，插入，删除、长度
qq_46093754的博客
07-19 1873
单链表线性表的链式存储，通过任意的存储单元来存储线性表中的数据元素。优点不需要大片的连续的空间，改变容量方便。缺点不可随机读取，要耗费一定空间存放指针。
数据结构单链表的创建，插入，修改，查找以及删除
10-24
数据结构单链表的创建，插入，修改，查找以及删除。线性表操作
单链表的创建、插入、删除、查找
04-02
include<stdio.h> #include<malloc.h> typedef int DataType; typedef struct node{ DataType data; struct node *next; }LinkList,*PLinkList; PLinkList Init_LinkList(void) { PLinkList H; H=(PLinkList)malloc(sizeof(LinkList)); if(H) H->next=NULL; return H; }
数据结构--单链表操作--实验报告.doc
07-11
上机实验报告 课程名称： 数据结构A 实验题目： 实验一 单链表操作 专业班级： 学 号： 姓 名： 完成日期： 2017年10月11日 成 绩： 1. 实验内容、目的和要求 1. 实验内容 单链表的创建、合并和输出。 【扩展内容】...
数据结构与算法实验（C++）：单链表实验-代码
01-18
1.内容概要： （1）实验目的： 1）熟练掌握单链表的存储特点； 2）熟练掌握单链表的基本操作算法； 3）熟练掌握面向对象程序设计方法； 4）能灵活使用单链表解决具体的问题。...数据结构与算法实验
数据结构-线性表-单链表的查找、插入、删除.doc
10-10
数据结构-线性表-单链表的查找、插入、删除.doc
数据结构实验-单链表的相关运算
最新发布
05-12
编写主函数，在主函数中调用建立单链表的算法创建一个单链表，然后调用查找、插入、删除算法。 运行调试，输入数据，并根据结果进行分析。 部分示例代码及程序运行参考界面如下所示，请完善程序，并撰写实验报告。
数据结构实验报告--单链表.docx
07-11
线性表存储结构（五选一）： 带头结点的单链表 不带头结点的单链表 循环链表 双链表 静态链表 线性表的基本功能： 构造：使用头插法、尾插法两种方法 插入：要求建立的链表按照关键字从小到大有序 删除 查找 获取...
【头歌】单链表的基本操作
热门推荐
qq_39977056的博客
01-23 1万+
由于单链表中每个结点的存储地址是存放在其前趋结点的指针域中的，而第一个结点无前趋，头指针L指向第一个结点，对于整个单链表的读取必须从头指针开始，同时，由于单链表中最后一个结点的指针域为“空”（NULL），没有直接后继元素，对于整个单链表的读取必须在尾结点结束。要在带头结点的单链表L中删除第i个结点，则同样要先找到第i-1个结点，使p指向第i-1个结点，使q指向第i个结点，然后令第i-1个结点的指针域指向第i+1个结点，而后删除q指向的第i个结点并释放结点空间。= NULL时，才能进行删除结点的操作。
单链表插入新节点问题
Christmas_d的博客
04-02 569
InsetNodeError函数内直接定义一个LNode结构体，而InsetNode使用的是结构体指针 最终在vs2017上第一种在打印输出时失败，第二种正常。 int InsetNodeError(LinkList &L, int i, ElemType e) { LNode* p = L; int j = 0; LNode s; s.data = e...
DS单链表--存储结构与操作
03-30
DS单链表是一种线性数据结构，它由若干个节点组成，每个节点包括数据域和指针域，其中数据域用于存储数据，指针域用于指向下一个节点。DS单链表的存储结构如下： ``` typedef struct ListNode { int val; struct ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值