学习笔记—数据结构—单链表

于 2025-03-16 16:03:11 发布
阅读量904 收藏 12
点赞数 31
分类专栏： 数据结构 文章标签： 数据结构 学习 笔记 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_83231468/article/details/146294363
版权

目录

前言：

一、单链表

1.1概念

1.2创建

(1)原理思路

(2)图像思路

(3)节点结构体

(4)动态创建节点

二、单链表的操作

2.1遍历

2.2插入

(1)头插

(2)尾插

(3)指定位置(pos)插入

2.3删除

(1)头删

(2)尾删

(3)指定位置(pos)删除

2.4查找

2.5销毁

三、总结

头文件SList.h

SList.c

测试文件test.c

补充

前言：

单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据部分和一个指向下一个节点的指针。在单链表中，每个节点的地址不一定是连续的，而是通过指针相互链接起来。单链表的特点是存储灵活，可以动态地添加或删除节点，不需要预先分配固定大小的存储空间。

一、单链表

1.1概念

链表是⼀种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的 指针链接次序实现的。

1.2创建

(1)原理思路

节点：与顺序表不同的是，链表⾥的每节"车厢"都是独立申请下来的空间，我们称之为“结点/结点”

结点的组成主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。

链表中每个结点都是独立申请的（即需要插⼊数据时才去申请⼀块结点的空间），我们需要通过指针变量来保存下⼀个结点位置才能从当前结点找到下⼀个结点。

● 定义节点结构体：首先需要定义一个结构体来表示链表的节点，通常包括数据域和指针域。

● 动态创建节点：使用malloc函数为每个节点分配内存空间，并初始化数据域和指针域。

● 插入节点：根据需要将新节点插入到链表的适当位置。

● 遍历链表：通过遍历链表，可以访问链表中的每个节点，通常用于打印或搜索特定数据

性质：

链式机构在逻辑上是连续的，在物理结构上不⼀定连续。

结点⼀般是从堆上申请的。

从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续。

(2)图像思路

(3)节点结构体

数域和指针域

typedef int SLTDateType;

typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

(4)动态创建节点

SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newcode = (SLTDateType*)malloc(sizeof(SListNode));
	if (newcode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newcode->data = x;
	newcode->next = NULL;

	return newcode;
}

二、单链表的操作

单链表的常见操作包括遍历、插入、删除和查找。这些操作通常涉及到对链表节点的指针进行操作，以实现数据的动态管理。

2.1遍历

链表和顺序表的区别顺序表内存是连续的，链表是由一个一个节点连接的，‘cur’ 指向的下一个节点赋值给‘cur’，cur = cur->next;

void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

2.2插入

(1)头插

void SListPushFront(SListNode** pplist, SLTDateType x)
{
	SListNode* newcode = BuySListNode(x);
	newcode->next = *pplist;
	*pplist = newcode;
}

(2)尾插

void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newcode = BuySListNode(x);

	if (*pplist == NULL)
	{
		*pplist = newcode;
	}
	else
	{
		//找尾
		SListNode* tail = *pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newcode;
	}
}

(3)指定位置(pos)插入

pos位置前面插入

void SLTInsert(SListNode** pplist, SListNode* pos, SLTDateType x)
{
	assert(pplist);
	assert(*pplist);

	SListNode* newcode = BuySListNode(x);
	if (pos == *pplist)
	{
		SListPushFront(pplist,x);
	}
	else
	{
		SListNode* cur = *pplist;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		newcode->next = pos;
		cur->next = newcode;
	}
}

pos位置后面插入

void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* newcode = BuySListNode(x);
	newcode->next = pos->next;
	pos->next = newcode;
}

2.3删除

(1)头删

void SListPopFront(SListNode** pplist)
{
	//节点断言
	assert(*pplist);

	SListNode* first = *pplist;
	*pplist = first->next;
	free(first);
	first = NULL;
}

(2)尾删

void SListPopBack(SListNode** pplist)
{
	//节点断言
	assert(pplist);
	assert(*pplist);
	//存在节点 1.存在一个节点 2.存在两个节点
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		//找尾

		//SListNode* tail = *pplist;
		//while (tail->next->next != NULL)
		//{
		//	tail = tail->next;
		//}
		//free(tail->next);
		//tail->next = NULL;

		SListNode* prv = NULL;
		SListNode* tail = *pplist;
		while (tail->next != NULL)
		{
			prv = tail;
			tail = tail->next;
		}

		free(tail);
		prv->next = NULL;
	}
}

(3)指定位置(pos)删除

pos位置之前删除

void SListEraseAfter(SListNode* pos)
{
	SListNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

pos位置删除

void SLTErase(SListNode** pplist, SListNode* pos)
{
	assert(pplist);
	assert(*pplist);

	SListNode* tail = *pplist;
	while (tail->next != pos)
	{
		tail = tail->next;
	}
	tail->next = pos->next;
	free(pos);
	pos = NULL;
}

pos位置之后删除

void SListEraseFront(SListNode** pplist,SListNode* pos)
{
	assert(pplist);
	assert(*pplist);

	SListNode* tail = *pplist;
	while (tail->next->next != pos)
	{
		tail = tail->next;
	}
	SListNode* del = tail->next;
	tail->next = pos;
	free(del);
	del = NULL;
}

2.4查找

SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	SListNode* cur = plist;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

2.5销毁

不可以直接销毁*pplist，内存存贮不是连续的需要一个一个销毁

void SLTDestory(SListNode** pplist)
{
	assert(pphead);
	SListNode* cur = *pphead;
	while (cur)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;

三、总结

头文件SList.h

#pragma once


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


typedef int SLTDateType;

typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 在pos的前面插入
void SLTInsert(SListNode** pplist, SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos); 
// 删除pos位置
void SLTErase(SListNode** pplist, SListNode* pos);
///删除pos前面的值
void SListEraseFront(SListNode* pos);
//单链表的销毁
void SLTDestory(SListNode** pplist);

SList.c

#define _CRT_SECURE_NO_WARNINGS
#include"SList.h"


//动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newcode = (SLTDateType*)malloc(sizeof(SListNode));
	if (newcode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newcode->data = x;
	newcode->next = NULL;

	return newcode;
}

//打印单链表
void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

//单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	SListNode* newcode = BuySListNode(x);

	if (*pplist == NULL)
	{
		*pplist = newcode;
	}
	else
	{
		//找尾
		SListNode* tail = *pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newcode;
	}
}


//单链表尾删
void SListPopBack(SListNode** pplist)
{
	//节点断言
	assert(*pplist);
	//if（(*pplist)==NULL）
	// return ;

	//存在节点 1.存在一个节点 2.存在两个节点
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		//找尾

		//SListNode* tail = *pplist;
		//while (tail->next->next != NULL)
		//{
		//	tail = tail->next;
		//}
		//free(tail->next);
		//tail->next = NULL;

		SListNode* prv = NULL;
		SListNode* tail = *pplist;
		while (tail->next != NULL)
		{
			prv = tail;
			tail = tail->next;
		}

		free(tail);
		prv->next = NULL;
	}
}


//单链表头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	SListNode* newcode = BuySListNode(x);
	newcode->next = *pplist;
	*pplist = newcode;
}

//单链表头删
void SListPopFront(SListNode** pplist)
{
	//节点断言
	assert(*pplist);

	SListNode* first = *pplist;
	*pplist = first->next;
	free(first);
	first = NULL;
}

//单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	SListNode* cur = plist;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* newcode = BuySListNode(x);
	newcode->next = pos->next;
	pos->next = newcode;
}

// 在pos的前面插入
void SLTInsert(SListNode** pplist, SListNode* pos, SLTDateType x)
{
	assert(pplist);
	assert(*pplist);

	SListNode* newcode = BuySListNode(x);
	if (pos == *pplist)
	{
		SListPushFront(pplist,x);
	}
	else
	{
		SListNode* cur = *pplist;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		newcode->next = pos;
		cur->next = newcode;
	}
}

// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
	SListNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

// 删除pos位置
void SLTErase(SListNode** pplist, SListNode* pos)
{
	assert(pplist);
	assert(*pplist);

	SListNode* tail = *pplist;
	while (tail->next != pos)
	{
		tail = tail->next;
	}
	tail->next = pos->next;
	free(pos);
	pos = NULL;
}

//删除pos前面的值
void SListEraseFront(SListNode** pplist,SListNode* pos)
{
	assert(pplist);
	assert(*pplist);

	SListNode* tail = *pplist;
	while (tail->next->next != pos)
	{
		tail = tail->next;
	}
	SListNode* del = tail->next;
	tail->next = pos;
	free(del);
	del = NULL;
}


//销毁链表
void SLTDestory(SListNode** pplist)
{
	assert(pplist);
	SListNode* cur = *pplist;
	while (cur)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pplist = NULL;

测试文件test.c

#define _CRT_SECURE_NO_WARNINGS


#include "SList.h"

void testSList1()
{
	SListNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);

	SListNode* ret = SListFind(plist, 2);
	//ret->data = (ret->data) * 3;

	//SListInsertAfter(ret, 66);

	SLTInsert(&plist, ret, 77);

	//SListEraseAfter(ret);

	//SLTErase(&plist, ret);

	SListEraseFront(&plist, ret);

	SListPrint(plist);

}

void testSList2()
{
	SListNode* plist = NULL;
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);


	SListPopFront(&plist);
	SListPopFront(&plist);

	SListPrint(plist);



}

int main()
{

	testSList1();
	//testSList2();


	return 0;
}

补充

单链表在链表中被称为：无头单向非循环链表

无头单向非循环链表：结构简单，⼀般不会单独用来存数据。实际中更多是作为其他数据结构的⼦ 结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

单链表的十三个基本操作（全）
Python、C++、HTML、Java
10-03 7456
有关单链表的十三个基本操作，包括了 1、初始化单链表 2、插入 3、删除 4、查找 5、逆置 6、排序 7、删除指定数 8、指定交换顺序 9、求单链表长度 10、修改 11、最大值 12、按序插入 13、删除重复值
【数据结构详细学习笔记2】单链表的定义和表示
longbow_nice的博客
07-09 2311
单链表基础知识，单链表代码实现，实现单链表遇到问题
单链表的运用
最新发布
2301_79180415的博客
12-08 94
个人的一点浅见，望各位大佬指导。
单链表的应用
jiaomubai的博客
09-09 435
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表。本文只针对单链表进行说明。一个单链表的节点包含两个值：当前节点的值和指向下一个节点的链接。 基本结构就如上图所示，其中数值 1 所在的节点为链表的头节点，头节点的 value 域存储当前节点的值，next 域存储指向下一个节点的链接。 Java 中 LinkedList 与 ArrayList 类似，是一种常用的数据容器。提供
单链表的简单使用
weixin_46272350的博客
07-05 447
单链表的简单操作
单链表及其用法
5431的专栏
04-15 1184
一、链表的定义 链表是一种物理存储单元上非连续、非顺序的存储结，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表是由一系列结点组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域。 二、链表的存储结构 链表的存储结构是链式存储，链式存储的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以
数据结构学习笔记——单链表
12-21
本文将深入探讨单链表这一常见数据结构，并与其他数据结构如数组进行对比。 单链表是一种线性数据结构，其特点是元素在内存中并非连续存储。每个节点由两部分构成：一个是存储数据的`data`变量，另一个是`next`指针...
数据结构学习笔记-单链表
02-16
本学习笔记将聚焦于单链表的概念、操作以及在VS2022环境下如何实现。 单链表是一种线性数据结构，其元素（节点）不是在内存中连续存储的，而是通过指针链接在一起。每个节点包含两部分：数据域和指针域。数据域用于...
数据结构单链表学习笔记
qq_52544734的博客
05-27 380
数据结构上机 单链表 尾插法创建链表 头插法创建链表 销毁链表 求链表长度 求单链表中第i个元素 在第i个节点前插入值为x的节点 在链表中查找元素值为x的节点 删除元素第i个元素节点 在递增有序的单链表l中插入一个值为x的元素保持递增有序 将单链表中的奇数项和偶数项分解开 求递增有序单链表中l1和l2的公共元素 放入新的单链表l3 删除重复元素 递增有序单链表L1、L2，不申请新结点，利用原表结点对2表进行合并，并使得合并后成为一个集合，合并后用L1的头结点作为头结点，删除L2的头结点，要求时间性能最好。
数据结构学习笔记||单链表
weixin_44954209的博客
06-08 559
单链表 插入和删除结点的操作 1）插入结点 在单链表中插入一个新结点需要找到插入后的前驱结点 代码描述： s->next=p->next; p->next=s; 2）删除结点 需要找到其前驱结点 代码描述 p->next=p->next->next 一般情况下，删除结点后还需要释放其内存空间 q=p->next; //q临时保存被删结点 p->next=q->next; //从链表中删除结点q free(
单链表的相关使用
weixin_53089999的博客
03-10 403
1.单链表的概念 单链表由数据元素和所对于的索引构成，并且有头节点，并且头节点 的数据为空。 首先建立单链表： 要明白但链表的属性，即成员变量，成员变量private Node head; private int N;需要有头节点记录开始，和长度，即数组的长度。 private Node head; //头节点 private int N//长度 //成员变量 链表要添加新节点数据就必须要有建立新节点的方法和相关的类 private class Node { T data ;//T表
单链表的基本用法
Burder的博客
04-04 535
俗话说，熟能生巧，刚刚接触链表的时候，可能觉得这东西太不好理解了，代码是敲出来的，所以把最基本的链表中增、删、改、除练习的特别熟的时候，才会更容易明白以后得双链表以及他们的反转和各类题型，千里之行始于足下，所以我把单链表最基本用法写出来，希望可以帮助到你。 初始化 public class data1 { public static class Node{ Node ne...
单链表的各种基本使用方法
凯撒袁六兽的blog
05-11 1201
单项链表的一些基础使用方法包括： 创造单链表，其中含有两种创造方法：头插法和尾插法 输出单链表 在单链表中查找某个节点 在单链表中插入新的节点 在链表中删除一个节点或者多个某个内容相同的节点 对单链表进行排序 创造一个有序的单链表 主函数中的引用 那么接下来我们逐个解析： 大前提是用结构体作为节点，结构体中包含节点的内容和指向下一个节点的地址 typedef struct node { int date; struct node *next; }Lnode,*Linked; 1.创造单
单链表的理解与使用及拓展
HyHarden的博客
08-14 2540
1、前言 由于顺序表要求将元素存储在一块连续的空间中，因此对顺序表的元素进行插入，删除时需要对元素进行移动，这些操作会耗费大量的时间。所以就有了链式表的产生。链式表不要求使用连续的存储空间来存储元素，它是通过连接的方式，来将不连续的物理空间连接成一条链式的逻辑上是相邻的结构。对链式表进行插入，删除等操作就不需要移动元素了，这样大大提高了效率。接下来介绍单链表，它是链式表中最基本的一种结构
单链表的基本操作和应用
m0_63569461的博客
05-24 2330
一、单链表的特点 有一个head 指针变量，它存放头结点的地址，称之为头指针。 头结点的指针域 head->next，存放首元结点(第一个实际有效结点)的地址。 每个结点都包含一个数据域和一个指针域，数据域存放用户需要的实际数据，指针域存放下一个结点的地址。从头指针 head开始，head 指向头结点，头结点指向首元结点，首元结点指向第二个结点，…，直到最后一个结点。所有结点都是单线联系环环相扣。 最后一个结点不再指向其他结点,称为“表尾结点”,它的指针域为空指针“NULL”,表示链表到此结束
【单链表的基本操作】
w_9420的博客
12-10 1064
链表的基本操作
链表的概念与单链表使用
a260256216的博客
07-12 236
链表 链表是由一组不必相连（不必相连：可以连续也可以不连续）的内 存结构（节点），按特定的顺序链接在一起的抽象数据类型。是离散存储线性结构，n 个节点离散分配，彼此通过指针相连，每个节点只有一个前驱节点，每个节点只有一个后续节点，首节点没有前驱节点，尾节点没有后续节点。 链表优点： 空间没有限制 插入删除元素很快 链表缺点： 存取速度很慢 链表的种类 单链表 双向链表 循环链表。 链表示意图 链表的结构图 单链表代码： public class userList { //data
链表的使用
雨沐风林的博客
02-07 226
链表的使用 （本文仅为笔者学习笔记，如有错误之处恳请各位读者指正） 简译：          你有一个破损的键盘。键盘上的所有键都可以正常工作，但有时Home键或者End键会自动按下。你并不知道键盘存在这一问题，而是专心地打稿子，甚至连显示器都没打开。当你打开显示器之后，展现在你面前的是一段悲剧的文本。你的任务是在打开显示器之前计算出这段悲剧文本。          输入包
大学生数据结构单链表操作学习资料大全
针对大学生的数据结构学习，本合集包含了丰富的学习笔记和资料，旨在帮助学生深入理解数据结构的核心概念、原理和应用。学习资料可能包括单链表的详细讲解、其他数据结构如栈、队列、树、图等的介绍，以及相应的算法...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值