【数据结构】线性表之单链表（讲解实现——带动图理解）

已于 2023-05-01 23:39:08 修改
阅读量667 收藏 12
点赞数 17
分类专栏： 数据结构理解与实现 文章标签： 数据结构 链表 开发语言 c语言
于 2023-05-01 23:30:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65596720/article/details/130460021
版权

文章目录

单链表

  • 单链表的优点

1.头部和中间插入或删除数据效率高，无需挪动。

2.按照需求申请释放空间，无需担心空间不够用。

  • 单链表的缺点

1.不可以进行下标随机访问。

2.复杂度是O(n)

3.反向遍历困难

单链表是线性表的一种，单链表是链式存储的线性表，不同于单链表，链表在内存空间中不连续，而是由结构体内的next指针下一条数据进行链接🧐

PS:需要源码直接通过目录跳转到最后

单链表主体结构

默认大小与扩容大小还有类型都可以是任意大小或类型

typedef int LLDataType;				//数据类型

typedef struct LinkedList
{
	LLDataType data;					//用于存放数据
	struct LinkedList* next;			//指向下一个数据
}LinkedList;

在这里插入图片描述

单链表操作函数介绍

  1. void printLL(LinkedList* Phead); //打印单链表
  2. void LLPushBack(LinkedList** PPhead, LLDataType x); //尾插
  3. void LLPushFront(LinkedList** PPhead, LLDataType x); //头插
  4. void LLPopBack(LinkedList** PPhead); //尾删
  5. void LLPopFront(LinkedList** PPhead); //尾插
  6. LinkedList* LListFind(LinkedList* phead, LLDataType x); //查找
  7. void SListInsertAfter(LinkedList* pos, LLDataType x); //在指定位置后插入
  8. void SListEraseAfter(LinkedList* pos); //删除指定位置后的一个表
  9. void SListDestroy(LinkedList** Phead); //销毁单链表
  10. void SListInsertFront(LinkedList** Phead, LinkedList* pos, LLDataType x); //在指定位置前插入
  11. void SListErase(LinkedList** PPhead, LinkedList* pos); //删除指定位置数据

为了代码方便阅读，讲单链表操作函数全部放在LinkedList.c文件中，将头文件放在LinkedList.h，测试文件test.c 😮

单链表操作函数实现

为了方便调试，建议每写完1-2个函数就进行测试，初始化之后，首先实现print函数可以方便我们进行调试。

单链表的初始化：

LinkedList *Phead = NULL;	//未进行插入之前，头结点指针指向NULL

必须先进性初始化，讲链表指向NULL避免野指针问题。

打印函数

写完插入立马写打印，方便进行调试

void printLL(LinkedList* Phead)
{
	while (Phead!=NULL)
	{
		printf("%d->", Phead->data);
		Phead = Phead->next;
	}
	printf("NULL");
}

单链表插入函数：

头插

头插将新结点插入到头结点

1.如果头结点不为空，头结点改为新插入的结点，原本的第一个位置的结点需要连接到新结点的next。

2.如果头结点为空，那么直接将新结点给到头结点指针phead

  • 既然有插入就一定会有空间不够用的问题，这里用到检查空间是否够用的一个函数
LinkedList* BuyNewNode(LLDataType x)		//申请一个新结点并将next指向空
{
	LinkedList* ret = (LinkedList*)malloc(sizeof(LinkedList));
	if (ret == NULL)
	{
		perror("Malloc:");
		return NULL;
	}
	ret->data = x;
	ret->next = NULL;
	return ret;
}

void LLPushFront(LinkedList** PPhead, LLDataType x)
 // 使用二级指针是因为我们要改变头结点，所有必须要使用头结点的指针来改变。
{
	assert(PPhead);			
	LinkedList* NewNode = BuyNewNode(x);
	if (*PPhead == NULL)
	{
		*PPhead = NewNode;
	}
	else
	{
		NewNode->next = *PPhead;
		*PPhead = NewNode;
	}
}

头结点为空

  • 如果头结点为空，那么直接将新结点给到头结点指针phead

在这里插入图片描述

头结点不为空

  • 如果头结点不为空，头结点改为新插入的结点，原本的第一个位置的结点需要连接到新结点的next。

在这里插入图片描述

尾插

从最后一个结点后面插入新结点

  • 尾插也会用到申请新结点的函数，这里不重复了
void LLPushBack(LinkedList** PPhead, LLDataType x)
// 使用二级指针是因为我们要改变头结点，所有必须要使用头结点的指针来改变。
{
	assert(PPhead);
	LinkedList* NewNode = BuyNewNode(x);	//也用到了上面的BugNode不重复了
	if (*PPhead == NULL)
	{
		*PPhead = NewNode;
	}
	else
	{
		LinkedList* tail = *PPhead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = NewNode;
	}
}

头结点不为空

  • 如果头结点不为空，先找到最后一个结点（指向NULL的就是最后一个结点），然后将新结点插入到最后一个结点的后面

在这里插入图片描述

头结点为空

  • 如果头结点为空，那么直接将新结点给到头结点指针phead(与上面头插头结点为空相同)

在这里插入图片描述

指定结点后插入和查找函数

相对上面两个简单，下面插入函数都需搭配查找结点函数使用，查找函数就是遍历，找到返回地址，比较简单，就不多描述了。

LinkedList* LListFind(LinkedList* phead, LLDataType x)
{
	assert(phead);
	LinkedList *ret = phead;
	while (ret->data != x)
	{
		if (ret == NULL)
		{
			return NULL;
		}
		ret = ret->next;
	}
	return ret;
}

void SListInsertAfter(LinkedList* pos, LLDataType x)
{
	assert(pos);
	LinkedList *newnode = BuyNewNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

在这里插入图片描述

单链表结点之前插入数据

void SListInsertFront(LinkedList** PPhead, LinkedList* pos, LLDataType x)
{
	assert(pos);
	assert(PPhead);
	if (*PPhead == NULL||*PPhead==pos)
	{
		LLPushFront(PPhead, x);
	}
	else
	{
		LinkedList* cur = *PPhead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		LinkedList* newnode = BuyNewNode(x);
		newnode->next = cur->next;
		cur->next = newnode;
	}
}
  • 头结点为空或插入结点就是头结点指向的结点，直接复用头插函数即可

在这里插入图片描述

  • 头结点不为空或插入结点就是头结点指向的结点，找到pos前一个结点进行插入

在这里插入图片描述

单链表删除函数

头删

从头部删除数据，将头结点位置删除，将头结点的下一个位置指向头结点

void LLPopFront(LinkedList** PPhead)
{
	assert(PPhead);
	assert(*PPhead);
	LinkedList* temp = (*PPhead)->next;
	free(*PPhead);			//释放掉删除的结点
	*PPhead = temp;
}

在这里插入图片描述

尾删

void LLPopBack(LinkedList** PPhead)
{
	assert(PPhead);
	assert(*PPhead);
	if ((*PPhead)->next == NULL)
	{
		*PPhead = NULL;
	}
	else
	{
		LinkedList* tail = *PPhead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}
  • 如果头结点为空，不能进行删除。
  • 如果头结点下一个为空，直接进行删除
  • 如果头结点和头结点的下一个都不为空，删除下一个结点为空的结点，那就需要找到头结点下一个结点的下一个结点为空的结点

在这里插入图片描述

指定结点后删除

后面的数据依次向前移动

void SListEraseAfter(LinkedList* pos)
{
	if (pos == NULL)
	{
		printf("没发现此数据");
		return;
	}
	if (pos->next == NULL)
	{
		printf("链表后面已经为空了\n");
		return;
	}
	LinkedList* temp = pos->next;
	pos->next = pos->next->next;
	free(temp);
}
  • 如果pos为空或pos->next为空则提示并返回

在这里插入图片描述

指定结点删除

删除指定结点，将指定结点的next连接到指定结点前面的next结点，然后释放指定的结点。

void SListErase(LinkedList**PPhead,LinkedList* pos)
{
	assert(pos);
	assert(PPhead);
	assert(*PPhead);
	if (pos == *PPhead)
	{
		LLPopFront(PPhead);
		return;
	}
	LinkedList* cur = *PPhead;
	while (cur->next != pos)
	{
		cur = cur->next;
	}
	cur->next = cur->next->next;
	free(pos);
}
  • 头结点指针指向的结点等于pos，复用尾插函数

在这里插入图片描述

销毁单链表

将每个结点依次释放。最后将头结点制空。

void SListDestroy(LinkedList** PPhead)
{
	assert(*PPhead);
	if (*PPhead == NULL)
	{
		printf("已经是空链表了\n");
		return;
	}
	while ((*PPhead)->next != NULL)
	{
		LinkedList* tep = (*PPhead)->next;
		(*PPhead)->next = (*PPhead)->next->next;
		free(tep);
	}
	free(*PPhead);
	*PPhead = NULL;
}

在这里插入图片描述

文件分类

🌞🌞为了使代码更有阅读性，我们不建议把所有函数写在一个文件里，所以这里分成三个文件，模块化管理

test.c

测试文件

#include "LinkedList.h"

int main()
{
	LinkedList *Phead = NULL;
	LLPushFront(&Phead, 8);
	LLPushBack(&Phead,2);
	LLPushBack(&Phead,3);
	LLPushBack(&Phead,4);
	LLPushBack(&Phead,5);
	//LLPopBack(&Phead);
	//LLPopFront(&Phead);
	//LLPopBack(&Phead);
	//LLPopFront(&Phead);
	//LLPopFront(&Phead);
	LinkedList* temp = LListFind(Phead, 3);
	SListInsertAfter(temp,88);
	temp = LListFind(Phead, 4);
	SListEraseAfter(temp);
	temp = LListFind(Phead, 4);

	SListInsertFront(&Phead,temp, 99);
	printLL(Phead);
	temp = LListFind(Phead, 99);
	SListErase(&Phead, temp);
	SListDestroy(&Phead);
}

LinkedList.c

将所有单链表需要的函数封装在此文件下⭐

#include "LinkedList.h"

LinkedList* BuyNewNode(LLDataType x)
{
	LinkedList* ret = (LinkedList*)malloc(sizeof(LinkedList));
	if (ret == NULL)
	{
		perror("Malloc:");
		return NULL;
	}
	ret->data = x;
	ret->next = NULL;
	return ret;
}

void LLPushBack(LinkedList** PPhead, LLDataType x)
{
	assert(PPhead);
	LinkedList* NewNode = BuyNewNode(x);
	if (*PPhead == NULL)
	{
		*PPhead = NewNode;
	}
	else
	{
		LinkedList* tail = *PPhead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = NewNode;
	}
}

void LLPushFront(LinkedList** PPhead, LLDataType x)
{
	assert(PPhead);
	LinkedList* NewNode = BuyNewNode(x);
	if (*PPhead == NULL)
	{
		*PPhead = NewNode;
	}
	else
	{
		NewNode->next = *PPhead;
		*PPhead = NewNode;
	}
}

void LLPopBack(LinkedList** PPhead)
{
	assert(PPhead);
	assert(*PPhead);
	if ((*PPhead)->next == NULL)
	{
		*PPhead = NULL;
	}
	else
	{
		LinkedList* tail = *PPhead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

void LLPopFront(LinkedList** PPhead)
{
	assert(PPhead);
	assert(*PPhead);
	LinkedList* temp = (*PPhead)->next;
	free(*PPhead);
	*PPhead = temp;
}

void printLL(LinkedList* Phead)
{
	while (Phead!=NULL)
	{
		printf("%d->", Phead->data);
		Phead = Phead->next;
	}
	printf("NULL");
}

LinkedList* LListFind(LinkedList* phead, LLDataType x)
{
	assert(phead);
	LinkedList *ret = phead;
	while (ret->data != x)
	{
		if (ret == NULL)
		{
			return NULL;
		}
		ret = ret->next;
	}
	return ret;
}

void SListInsertAfter(LinkedList* pos, LLDataType x)
{
	assert(pos);
	LinkedList *newnode = BuyNewNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SListInsertFront(LinkedList** PPhead, LinkedList* pos, LLDataType x)
{
	assert(pos);
	assert(PPhead);
	if (*PPhead == NULL||*PPhead==pos)
	{
		LLPushFront(PPhead, x);
	}
	else
	{
		LinkedList* cur = *PPhead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		LinkedList* newnode = BuyNewNode(x);
		newnode->next = cur->next;
		cur->next = newnode;
	}
}

void SListEraseAfter(LinkedList* pos)
{
	if (pos == NULL)
	{
		printf("没发现此数据");
		return;
	}
	if (pos->next == NULL)
	{
		printf("链表后面已经为空了\n");
		return;
	}
	LinkedList* temp = pos->next;
	pos->next = pos->next->next;
	free(temp);
}


void SListErase(LinkedList**PPhead,LinkedList* pos)
{
	assert(pos);
	assert(PPhead);
	assert(*PPhead);
	if (pos == *PPhead)
	{
		LLPopFront(PPhead);
		return;
	}
	LinkedList* cur = *PPhead;
	while (cur->next != pos)
	{
		cur = cur->next;
	}
	cur->next = cur->next->next;
	free(pos);
}
 
//void SListDestroy(LinkedList** Phead)
//{
//	assert(Phead);
//	if (*Phead == NULL)
//	{
//		printf("已经是空链表了");
//		return;
//	}
//	while ((*Phead) != NULL)
//	{
//		LinkedList* temp = *Phead;
//		*Phead = (*Phead)->next;
//		free(temp);
//	}
//}

void SListDestroy(LinkedList** PPhead)
{
	assert(*PPhead);
	if (*PPhead == NULL)
	{
		printf("已经是空链表了\n");
		return;
	}
	while ((*PPhead)->next != NULL)
	{
		LinkedList* tep = (*PPhead)->next;
		(*PPhead)->next = (*PPhead)->next->next;
		free(tep);
	}
	free(*PPhead);
	*PPhead = NULL;
}

LinkedList.h

将主程序所需要的函数全部在头文件中声明，增加代码阅读性⭐

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int LLDataType;

typedef struct LinkedList
{
	LLDataType data;
	struct LinkedList* next;
}LinkedList;

void printLL(LinkedList* Phead);
void LLPushBack(LinkedList** PPhead, LLDataType x);
void LLPushFront(LinkedList** PPhead, LLDataType x);
void LLPopBack(LinkedList** PPhead);
void LLPopFront(LinkedList** PPhead);
LinkedList* LListFind(LinkedList* phead, LLDataType x);
void SListInsertAfter(LinkedList* pos, LLDataType x);
void SListEraseAfter(LinkedList* pos);
void SListDestroy(LinkedList** Phead);
void SListInsertFront(LinkedList** Phead, LinkedList* pos, LLDataType x);
void SListErase(LinkedList** PPhead, LinkedList* pos);

撒花

这就是实现单链表的全部内容了，创作不易，还请各位小伙伴多多点赞👍关注收藏⭐，以后也会更新各种关于c语言，数据结构的博客，撒花！

悲伤的猪大肠9
关注
  • 17
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
专栏目录
数据结构---线性表(单循环链表)
yimo_5288的博客
12-13 267
CircleList.h #ifndef __CIRCLELIST_H__ #define __CIRCLELIST_H__ //一些库函数的头文件包含 #include &lt;string.h&gt; #include &lt;ctype.h&gt; #include &lt;malloc.h&gt; #include &lt;limits.h&gt; #include &lt;std...
数据结构之线性表（链式表示之单链表）
RDJE56523的博客
03-17 279
定义： 线性表的链式存储又称单链表 typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; 基本操作： 头插法建立单链表： LinkList List_HeadInsert(LinkList &L){ LNode *s;int x; L=(LinkList)malloc(sizeof(LNode)...
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc 知识点摘要： 1. 数据结构的基本概念：数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。 2. 线性表的概念：线性表是一种基本...
数据结构c版（1）-线性表之单链表代码
11-19
在这个“数据结构C版（1）-线性表之单链表代码”中，我们将深入探讨线性表这一基础数据结构的C语言实现，特别是单链表。 单链表是一种线性数据结构，其中的元素并非在内存中连续存储，而是通过指针连接。每个元素...
数据结构 线性表算法例题讲解.docx
02-08
线性表是数据结构中的基本概念，它是由n（n≥0）个相同类型元素构成的有限序列。在本文件中，我们主要讨论了三种线性表操作的算法：合并线性表、有序线性表的合并以及顺序线性表的插入。 **例1：合并LA、LB中的元素...
数据结构——二叉树性质
鲸落博客
07-23 293
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
数据结构-＞线性结构-＞顺序存储-＞静态链表
qq_68495605的博客
07-20 218
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
数据结构(5.2_3)——二叉树的存储结构
m0_65240792的博客
07-19 315
1%29%5D1。
《数据结构-用C语言描述第三版》课后答案 第三章
m0_62469100的博客
07-19 1077
b[2] = 2;b[n+1] = 2;i>=2;i--){若调用 bin ( A ,5)，给出 A 数组中第1个到第6个数组元素的值。答：数组中的值为每次递归将后面一个元素赋值为2，然后前面的元素分别加等其前面的元素。
《数据结构1800题》基础回合总结——第2章 线性表
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-23 284
和删除第一个结点不必另作判断。另外，不论链表是否为空，链表指针不变。这个要能够表达清楚。如果不设置头结点，边界情况需要特殊处理~应用题看了一下，不想在基础回合更新了，其实程序填空各位也可以暂时忽略——主要是使插入和删除等操作统一，在第一个元素之前插入。如果能保证客观题正确率100%，这本题就没白刷~刷《1800》的意义在于，
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 913
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
数据结构 - 队列（精简介绍）
mydaily_的博客
07-19 470
循环队列（Circular Queue），也称为环形队列，是一种队列数据结构，它将队列的最后一个位置连接到队列的第一个位置，使其形成一个环。在循环队列中，队列的前端和后端都可以绕回到数组的起始位置，从而有效利用数组的空间。单端队列升级版，允许在队头和队尾都进行元素的插入删除操作。，队列中元素会根据某种规则进行优先级排序。只能从尾部插入，头部取出元素。普通队列为单端队列，先进先出（FIFO）
数据结构（特殊二叉树-平衡二叉树）
weixin_65029285的博客
07-23 579
待删除节点左右子树非空，则根据左右子树的高度，选择高的一边子树，如果是左子树高，选择左子树中的最大节点赋值给待删除节点，然后再左子树中继续删除该最大节点，相当于继续处理情况1或情况2；由于节点的位置要受到相互之间值的影响，并且在往平衡二叉树中添加节点或者删除节点前，二叉树本身是平衡的，所以只可能在最后操作的节点附近不满足平衡条件，因此需要在该过程中对该节点进行判断并调整。如果一个搜索二叉树呈现或接近单支状，它的查找效率很低，很接近链表，因此如果能让它平衡时，查找效率最高。待删除的节点是叶子节点，直接删除。
数据结构之栈详解
最新发布
m0_73634434的博客
07-23 329
栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。，相对而言数组的结构实现更优一些。栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。整合以上我们来实现栈，下面是实现栈的完整代码。压栈：栈的插入操作叫做进栈/插栈/入栈，这里定长的静态栈的结构，实现中一般不实用。所以我们主要实现下面的支持动态增长的栈。出栈：栈的删除操作叫做出栈。->6. 查看栈中有没有元素。栈所需要实现的一些功能。->5. 查看栈的大小。栈的实现一般可以使用。->4. 删除栈元素。
从零开始学习嵌入式----数据结构
D1557329860的博客
07-19 302
数据结构知识。数据结构是计算机科学中用于组织、管理和存储数据的方式。不同的数据结构可以提供不同的功能，以满足不同的应用需求。
数据结构——二叉树定义
鲸落博客
07-23 112
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
《数据结构：栈和队列》
2401_83305953的博客
07-19 625
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以由数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈/，入数据在栈顶。
数据结构实验：线性表与单链表逆置
"这份文档是鞍山师范学院...实验通过这两个操作，帮助学生理解线性表的动态特性，掌握顺序存储和链式存储的区别，以及如何在实际编程中实现这些基本操作。这些基础概念和技能在后续的算法设计和数据处理中至关重要。
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值