数据结构——单链表（附图文讲解 | 超详细）

原创 于 2026-07-26 17:01:01 发布 · 5.7k 阅读 · 24 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

文章目录

一、前言

这篇博客将从全面讲解数据结构中的单链表

二、单链表

2.1 定义

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

链表由一系列节点组成，每个节点包含两部分：数据域和指针域。数据域用于存储实际的数据，而指针域则存储指向链表中下一个节点的地址。在单链表中，除了最后一个节点外，每个节点的指针域都指向下一个节点，最后一个节点的指针域通常设置为NULL，以标识链表的结束。单链表的特点是其存储不需要连续的内存空间，节点可以分散在内存中的任意位置，通过指针连接形成线性结构。

在这里插入图片描述

特点
  1. 节点结构：每个节点包含数据域和指针域（指向下一个节点）。
  2. 单向指向：只能从头节点向后遍历，无法反向访问前驱节点。
  3. 非连续存储：逻辑上连续，物理上内存可任意分布，靠指针维系顺序。
  4. 动态大小：长度不固定，按需申请/释放节点，无需预估容量。
  5. 插入/删除高效：在单链表中插入和删除的时间复杂度为 O(1)，仅需修改指针，无需移动元素。

2.2 单链表的实现

2.2.1 准备工作

先创建三个文件

在这里插入图片描述

解释这三个文件的作用
1. 头文件SList.h是来声明接口函数，定义单链表，将几个公共用到的库函数集合起来
2. 源文件SList.c是用来具体实现接口
3. 源文件test.c用于接口的测试工作 ，即具体的使用场景
2.2.1 单链表的功能接口
1.创建一个单链表
//单链表
typedef int SLTDataType; //自定义数据元素类型
typedef struct SListNode 
{
	SLTDataType data; //数据域 存储的数据
	struct SListNode* next; //指针域 指向下一个结点
}SLTNode;
2.销毁单链表
//销毁链表
void SListDestroy(SLTNode** pphead)
{
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}
3.单链表的打印
//链表的打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d -> ", pcur->data);
		pcur = pcur->next;
        //对pcur解引用拿到next指针变量中的地址（下一个节点的地址）
        //赋值给pucr，此时pcur保存的地址为下一个节点的地址，即pcur“指向了下一个节点”
	}
	printf("NULL\n");
}
4.节点的创建

单链表的每次增加都涉及到节点的创建

//节点的创建
SLTNode* SLTbuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}
5.单链表的增加功能接口

5.1 尾插接口

若链表为空则直接创建一个节点作为链表，若不为空则将最后一个节点的指针域改成新建的节点的指针

在这里插入图片描述

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTbuyNode(x);
	//链表为空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else 
    {
		//找尾
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;
	}
}

5.2 头插接口

将第一个节点的地址赋值给新建的节点的指针域，再将链表头指向新建节点的地址

在这里插入图片描述

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTbuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

5.3 指定位置之前插入接口

若指定位置是第一个位置，则用头插的方法，若不是第一个位置，则将prev的指针域改成新建的节点的地址，再将新建的节点的指针域改成pos的地址

在这里插入图片描述

//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && pos);
	//当pos指向第一个结点，是头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else 
    {
		SLTNode* newnode = SLTbuyNode(x);
		//找pos的前一个结点
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}

5.4 指定位置之后插入接口

先将pos中指针域中的地址（指定位置之后一位的地址）给新建的节点的指针域，再将新建的节点的地址赋值给pos中的指针域

在这里插入图片描述

//在指定位置之后插⼊数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTbuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
6.单链表的删除功能接口

6.1 尾删接口

若只有一个节点，则将这个节点销毁，若不止一个，则将倒数第二个节点的指针域中的地址赋为NULL，再将最后一个节点销毁

在这里插入图片描述

//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);
	//只有一个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else 
    {
		SLTNode* prev = NULL;
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}

6.2 头删接口

先将链表头指向第二个节点，再将第一个节点销毁

在这里插入图片描述

//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);

	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

6.3 删除指定位置接口

先将prev位置的节点中的指针域改成pos位置的节点中的指针域中的地址（pos下一个位置的节点地址），再将pos位置的节点销毁

在这里插入图片描述

//删除指定位置结点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && pos);
	//pos就是头结点
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else 
    {
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

6.4 删除指定位置之后接口

先将pos的指针域中的地址（指定位置之后的节点地址）保存起来，再将指定位置节点中的指针域中的地址（指定位置后两位节点的地址）赋给pos位置节点的指针域，最后将指定位置的节点销毁

在这里插入图片描述

//删除指定位置之后的结点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}
7.单链表的查找实现接口

一个一个进行比对

//单链表的查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

三、总代码

SList.h

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

//定义链表的结构---结点的结构
typedef int SLTDataType;
typedef struct SListNode 
{
	SLTDataType data;//存储的数据
	struct SListNode* next; //指向下一个结点
}SLTNode;

//typedef struct SListNode SLTNode;

//链表的打印
void SLTPrint(SLTNode* phead);

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SLTPopBack(SLTNode** pphead);
//头删
void SLTPopFront(SLTNode** pphead);

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在指定位置之后插⼊数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos之后的结点
void SLTEraseAfter(SLTNode* pos);

//销毁链表
void SListDestroy(SLTNode** pphead);

SList.c

#include"SList.h"
//链表的打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d -> ", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

SLTNode* SLTbuyNode(SLTDataType x)
{
	//根据x创建节点
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTbuyNode(x);
	//链表为空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else {
		//找尾
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;
	}
}
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTbuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);
	//只有一个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else {
		SLTNode* prev = NULL;
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}
//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);

	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}
//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && pos);
	//当pos指向第一个结点，是头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else {
		SLTNode* newnode = SLTbuyNode(x);
		//找pos的前一个结点
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}
//在指定位置之后插⼊数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTbuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && pos);
	//pos就是头结点
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else {
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
//删除pos之后的结点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

//销毁链表
void SListDestroy(SLTNode** pphead)
{
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

test.c

#include"SList.h"

void test01()
{
	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));

	node1->data = 1;
	node2->data = 2;
	node3->data = 3;
	node4->data = 4;

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;

	SLTNode* plist = node1;
	SLTPrint(plist);
}

void test02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
	//SLTPushFront(&plist, 1);
	//SLTPushFront(&plist, 2);
	//SLTPushFront(&plist, 3);
	//SLTPushFront(&plist, 4);
	//SLTPrint(plist);
	//SLTPushFront(NULL, 4);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//
	//SLTPopBack(&plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//
	//SLTPopFront(&plist);

	SLTNode* find = SLTFind(plist, 4);
	
	//SLTInsert(&plist, find, 100);//1 2 3 100 4 
	//SLTInsertAfter(find, 100);//1 100 2 3 4
	//SLTErase(&plist, find);
	//SLTEraseAfter(find);//1 3 4
	//SLTPrint(plist);

	SListDestroy(&plist);
}

int main()
{
	test01();
	test02();
    
	return 0;
}
标签
#数据结构 #学习 #c语言
【数据结构】单链表的接口实现（附图解和源码）
铭哥不写bug的博客
02-18 1570
本文详细介绍单链表的接口实现（附图解和源码），结尾附有整体源代码
手写单链表（指针）（next域）附图
ltl1的博客
12-21 2724
还是回到那张图：把尾的next变成tmp。tail = tmp;最后size++;tail = tmp;size++;
链表详解&&与顺序表对比
Yulu_Gan的博客
10-13 505
链表 单向链表 p是头节点，指向第一个值，最后一个是伪节点，因为不指向地址。 表元素域elem用来存放具体的数据 链接域next用来存放下一个节点的位置（python中的标识） 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点 ...
数据结构————单链表
2301_78402352的博客
09-29 1118
否则会导致链表的丢失。
C语言菜鸟入门·数据结构·链表超详细解析
时光の尘的博客
08-06 6207
对比于顺序表的每个节点只存放数据元素，单链表的每个节点除了存放数据元素外，还要存储指向下一个节点的指针。优点：可随机存储，存储密度较高；缺点：要求大片连续空间，改变容量不方便。优点：不要求大片连续空间，改变容量方便；缺点：不可随机存取，要耗费一定空间存放指针。对于单链表的每一个结点，都需要有一个数据域用于存放节点的数据元素，需要一个指针域用于指向下一个结点。而若是我们想要增加一个新的结点，我们可以使用malloc关键字，例如：首先，我们先声明一个指向。
【数据结构】单链表
2401_86785052的博客
03-23 1177
本期博客详细解读了单链表的深入结构，讲解了传值与传址的区别，手搓单链表，深度理解数据结构！
【数据结构】详解单链表（C语言实现）
talk less, code more
11-22 1289
C语言详细解释单链表。
[数据结构]链表之单链表（详解）
m0_63123468的博客
03-28 1万+
[数据结构]链表之单链表的详细解析
【单链表增删插改查的函数编写】
2401_86810295的博客
11-14 760
单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据域和一个指向下一个节点的指针域。通过指针将各个节点连接起来，形成一个单链表。int data;}Node;定义了一个名为Node的结构体，它包含两个成员：一个是存储数据的整型类型data，另一个是指向下一个节点的指针类型next，通过这个指针可以将多个节点逐个连接起来形成单链表。typedef->Node：使代码更简洁明了，引用数据类型别名可增强程序的通用性、灵活性、可读性、可移植性。
数据结构之线性表和单链表（二）
An Insecure Programming
08-30 805
线性表 定义 线性表是最基本、最简单、也是最常用的一种数据（线性）结构 线性表：具有像线一样性质的表。由n(n≥0)个数据元素（结点）a1,a2…,an组成的有限序列。 【注意】： a.首先线性表是一个序列，即元素之间是有顺序的。 b.线性表是有限的，元素个数有限，数据元素的个数n定义为表的长度（n=0时为空表） c.数据元素ai（1≤i≤n）只是个抽象符号，其具体含义在不同情况下...
【数据结构】队列的接口实现（附图解和源码）
铭哥不写bug的博客
02-27 1241
本文介绍了队列8种接口的模拟实现的图解+源代码，如果我的博客对你有所帮助记得三连支持一下，感谢大家的支持！
链表反转步骤分解附图leetcode 206题目迭代求解法
sinat_22510827的博客
10-10 201
结合代码分析： 步骤一、current指向头节点，current_next指向current的下一个节点，current_previous指向空。 步骤二、current的指针域指向current_previous,更新current_previous和current. 步骤二 ①：current的指针域指设置为current_previous 步骤二 ②：更新cu...
单链表实现学生成绩管理系统的增删改查
VarryTan的博客
06-04 1万+
写在前面：这个代码除了实现基本的数据增删改查外，还对数据进行了按学号排序输入，输出到文档中！同时对界面实现了优化！对数据插入方法使用插入排序！以及人数的统计，多种查询方式等！代码是很久之前写的，当时刚好学了单链表这一块，最近碰巧在磁盘里看到了就把它发了出来，顺便把文件操作内容补充了！ //全局定义两个指针变量（头指针和尾指针）；头指针用来遍历，尾指针用来添加Student成员；实现结果就不附图...
单链表反转
万事屋银ちやん
10-19 218
配套的单链表实现在另一篇博客。 因为是C#来解决的嘛，这个问题解决的话，所以用While循环和三个引用来做。 /// <summary> /// 反转链表 /// </summary> public Link<T> ReversalLinkList() { ...
2025年数据结构与算法面试全攻略：高频真题深度解析（附图详解）
最新发布
一起探索IT的世界
10-16 1341
​labuladong的算法小抄​​链接labuladong的算法小抄网站​GitHub​特点​：总结了大量算法的通用框架和“套路”，非常实用。​代码随想录​​链接​特点​：题目分类科学，刷题路线清晰，讲解视频通俗易懂，广受好评。本文详细剖析了2025年技术面试中最高频的数据结构问题，涵盖了从基础数组到高级的Trie和拓扑排序。要成功通过面试，仅靠记忆答案是不够的，你需要：​理解本质​：明白每种数据结构的特性和适用场景（如为什么LRU用哈希表+双向链表）。​掌握思想。
数据结构与算法 | 单链表的基本操作
热门推荐
嵌入式大杂烩
02-13 4万+
线性表的存储结构有顺序存储结构（顺序表）和链式存储结构（链表）两种。顺序表在之前的博客有介绍过，不明白的朋友可查看：静态分配顺序表的基本操作及动态分配顺序表的基本操作。相对于顺序表来说，链表稍微难一些，本人花了两天的时间认真查看了一些资料，终于大致明白了一些东西。现在做一些总结，分享给大家，有错误的地方欢迎大家指正。 一、相关概念术语
数据结构-单链表详解
快乐的小小程序猿
09-21 7278
#include <stdio.h> #include <malloc.h> /** * 定义结点类型结构体，有一个data域和一个next域 */ typedef struct LNode { int data; struct LNode* next; }LNode, * LinkList; /** * 初始化，生成带有头结点的单链表 * @param L ...
链表的理解与实现[数据结构]
Going Perfect
01-27 4641
一、链表的定义n个节点离散分配，节点之间通过指针相连。除了首节点和尾节点之外，每个节点都只有一个前驱结点和一个后继节点。 如下图： 大家有没有发现，链表的结构很像一种交通工具，什么呢？ 火车。（节点==车厢，指针==车厢间相连的绳索）二、链表的实现注意，这里实现的是链表中最简单的单链表。1、创建链表1.1 定义链表最基本的组成元素–节点我们由上面链表的定义可以知道，链表的每个节点应该含有两
头疼的算法与数据结构——单链表详解
sum_TW的博客
03-06 3549
一、链表简介 1.基本信息 链表是一种常见的数据结构，不同于数组，在内存中是连续的一段内存空间，，虽然是一种线性表但是不会按照线性顺序去存储数据的数据结构，而是在每一个节点里存到下一个节点的指针(Pointer）。由于不必按顺序存储，链表在插入的时候可以达到O⑴的复杂度，比另一种线性表：顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n）的时间，而顺序表相应的时间复杂度分别是O(
数据结构之链表解析
WangHuanToBeBest
09-18 244
单向链表逆序循环完整实现（c++语言） 单向链表逆序递归完整实现（c++语言） 代码实现如下（循环）： #include #include using namespace std; struct linkNode { int val; linkNode *next; linkNode(int x):val(x),next(NULL) { } }; linkNode *reverse2(li...
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值