【数据结构——单链表】

SHARK_pssm2026-06-07 8:32

目录

一、顺序表和链表的区别

不同点 顺序表 链表
存储空间上 物理上一定连续 逻辑上连续，但物理上不一定连续
随机访问（可用下标随机访问） 支持O(1) 不支持O(N)
任意位置插入或者删除元素 可能需要搬移元素，效率低O(N) 只需修改指针指向
插入 动态顺序表，空间不够时需要扩容（扩容本身有消耗，会造成空间浪费） 没有容量的概念
应用场景 元素高效存储+频繁访问 任意位置插入和删除频繁
缓存利用率 高 低

二、链表的分类

链表的结构多样，以下情况组合起来有8种链表结构

三、单链表

不带头单向不循环链表

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

例：

单链表也是线性表的一种：

链表 { 物理结构：不一定线性 逻辑结构：线性 链表\begin{cases} 物理结构：不一定线性\\ 逻辑结构：线性 \end{cases} 链表{物理结构：不一定线性逻辑结构：线性

单链表由一个一个的节点组成：

节点的组成部分 { 数据 指向下一个节点的指针 节点的组成部分\begin{cases} 数据\\ 指向下一个节点的指针 \end{cases} 节点的组成部分{数据指向下一个节点的指针

四、单链表的定义

定义单链表其实就是在定义单链表的节点的结构

c 复制代码 
struct SListNode
{
	int data;//存储的数据
	struct SListNode* next;//指向下一个节点的指针，类型为结构体指针
};

定义的改进：

c 复制代码 
typedef int SLTDataType;//替换类型更加方便
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;//给链表改名为SLTNode

五、申请节点

只要插入数据就要判断一下空间是否足够，因此可以将它单独写为一个方法

单链表每个节点独立零散分配，申请新节点采用malloc：

c 复制代码 
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode=(SLTNode*)malloc(sizeof(SLTNode));//申请新节点
	//判断是否申请成功
	//申请失败
	if(newnode==NULL)
	{
		perror("malloc fail!");
		exit(1);//异常退出给非零退出码
	}
	//申请成功
	newnode->data=x;//在新节点存储数据
	newnode->next=NULL;//新节点指向NULL
	return newnode;//返回新节点地址
}

返回值为新节点地址： 如果不返回的话需要用二级指针/全局变量接收，会很麻烦

六、单链表的增删查改

1.尾插

（1）尾插的思路

先定义一个指针ptail指向头节点，ptail从头往后找到尾节点，将尾节点和新节点连接起来

（2）找尾节点

while循环找尾节点

c 复制代码 
SLTNode* ptail=phead;//定义一个指向头节点的指针
//从头往后找
while(ptail->next)//不能以ptail!=NULL为结束条件，因为这样循环结束ptail不指向尾节点
{
	ptail=ptail->next;//不为空ptail往后走
}

ptail->next不能对空链表解引用，会报错

因此需要对空链表和非空链表分类讨论

（3）将尾节点和新节点连接起来

分为两种情况，链表为空和不为空

c 复制代码 
SLTNode* newnode=SLTBuyNode(x);//申请新节点
if(phead==NULL)//链表为空，头节点指向NULL
{
	phead=newnode;//申请的新节点就是头节点
}
else//链表不为空
{
	SLTNode* ptail=phead;
	while(ptail->next)
	{
		ptail=ptail->next;
	}
	ptail->next=newnode;//让原尾节点指向新节点
}

（4）传值与传址

调试上面的代码我们会发现phead形参改变了，但是plist实参始终为空没有改变，说明我们这里是传值

要让形参的改变影响实参必须传址

由于传的是一级指针的地址，因此这里需要用二级指针来接收

要传：

SLTNode** pphead

表达式 类型 存储内容 用法
pphead SLTNode** 指针的地址 找到pphead的位置
*pphead SLTNode* 头节点地址 修改头指向，头插、删头节点
**pphead SLTNode 整个结构体实体 访问结构体内部成员

（5）尾插完整代码

c 复制代码 
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//传入pphead不能为空，为空无法解引用
	SLTNode* newnode = SLTBuyNode(x);//申请新节点
	//如果链表为空
	if (*pphead == NULL)//头节点指向NULL，链表为空
	{
		*pphead = newnode;//申请的新节点就是头节点
	}
	else
	{
		SLTNode* ptail = *pphead;//定义一个ptail指针指向头节点
		while (ptail->next)
		{
			ptail = ptail->next;//ptail往后走
		}
		ptail->next = newnode;//将尾节点和新节点连接起来
	}
}

2.头插

（1）头插思路

将newnode（新节点）和原头节点连接在一起，再将新节点作为链表的头节点

当原链表为空时上述思路仍然成立

（2）头插完整代码

c 复制代码 
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//二级指针传过来的内容不能为空
	SLTNode* newnode = SLTBuyNode(x);//申请新节点
	newnode->next = *pphead;//将newnode与原头节点连接在一起
	*pphead = newnode;//newnode成为新的头节点
}

3.尾删

（1）尾删思路

定义一个指针ptail从头往后找尾节点，并定义一个指针prev从头往后走指向尾节点的前一个节点，找到后释放尾节点，并将原尾节点的前驱节点指向NULL

Tips：最前面要加上头节点里的内容和链表都不能为空的判断

c 复制代码 
assert(pphead && *pphead);//头结点里的内容和链表都不能为空

（2）利用循环实现思路

Tips：ptail找到尾节点之后不能直接释放，因为这不会改变尾节点的上一个节点的指针指向的地址，会导致上一个节点的指针变成野指针

c 复制代码 
SLTNode* ptail=*pphead;
SLTNode* prev=*pphead;
while(ptail->next)
{
	prev=ptail;//在ptail继续往下走之前先让prev指向ptail的节点
	ptail=ptail->next;//ptail继续往下走
}
free(ptail);//释放ptail指向的节点的空间
ptail=NULL;//ptail置空
prev->next=NULL;//prev指向NULL

问题： 如果链表里只有一个节点，ptail和prev开始时就指向NULL，不进入循环，ptail指向的节点释放时prev指向的节点也释放了，这时无法使prev指向NULL

解决： 这个时候我们采用直接释放这个节点的方式，无需找尾节点和前驱节点

（3）若链表里只有一个节点

若链表里只有一个节点，直接释放，然后使*pphead指向NULL

c 复制代码 
if((*pphead)->next==NULL)//链表只有一个节点，->优先级高于*，因此要套括号
{
	free(*pphead);//直接释放头结点空间
	*pphead=NULL;//*pphead置空
}

（4）尾删完整代码

c 复制代码 
void SLPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);
	if((*pphead)->next==NULL)
	{
		free(*pphead);
		*pphead=NULL;
	}
	else
	{
		SLTNode* ptail=*pphead;
		SLTNode* prev=*pphead;
		while(ptail->next)
		{
			prev=ptail;
			ptail=ptail->next;
		}
		free(ptail);
		ptail=NULL;
		prev->next=NULL;
	}
}

4.头删

（1）头删的思路

先把第二个节点存储在next指针中，接着释放头节点，然后让*pphead指向原来的第二个节点的位置

Tips：不能在找到头节点后直接释放，然后再让*pphead指向原来的第二个节点，这样会导致找不到第二个节点

以上思路既适用于链表中有多个节点，也适用于链表中只有一个节点

（2）头删完整代码

c 复制代码 
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);//传过来的参数和链表都不能为空
	SLTNode* next = (*pphead)->next;//存储第二个节点
	free(*pphead);//释放原头节点
	*pphead = next;//*pphead指向原来的第二个节点
}

5.查找

c 复制代码 
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;//定义一个pcur，避免再次后续需要手动修改phead及影响到phead的可能
	while (pcur)//等价于pcur!=NULL
	{
		if (pcur->data == x)//如果找到x
		{
			return pcur;//返回pcur
		}
		pcur = pcur->next;//如果未找到，继续往后遍历
	}
	//如果遍历完仍未找到
	return NULL;
}

6.在指定位置之前插入数据

（1）思路

*pphead指向头节点，pos指向指定位置节点，定义一个prev指针，从头找pos的前一个节点并让prev指向它，然后申请新节点，让新节点指向指定位置节点，指定位置的前驱节点指向新节点

（2）prev找pos的前驱节点

c 复制代码 
SLTNode* prev=*pphead;
while(prev->next!=pos)//循环的结束条件是prev的下一个节点是pos
{
	prev=prev->next;//下一个节点不是pos，prev继续往后走
}

（3）重新连接三个节点

c 复制代码 
SLTNode* newnode=SLTBuyNode(x);//申请新节点
newnode->next=pos;//新节点指向指定位置节点
prev->next=newnode;//指定位置的前驱节点指向新节点

（4）头插情况的讨论

当pos==*pphead时，循环不断往下走prev会指向NULL，而prev->next会报错无法对空指针解引用，因此需要分类讨论

如果是头插情况的话直接采用头插方法

c 复制代码 
if(pos==*pphead)
{
	SLTPushFront(pphead,x);
}

（5）完整代码

c 复制代码 
void SLTInsert(SLTNode** pphead,SLTNode* pos,SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	if(pos==*pphead)
	{
		SLTPushFront(pphead,x);
	}
	else
	{
		SLTNode* newnode=SLTBuyNode(x);
		SLTNode* prev=*pphead;
		while(prev->next!=pos)
		{
			prev=prev->next;
		}
		newnode->next=pos;
		prev->next=newnode;
	}
}

7.在指定位置之后插入数据

（1）思路

pos指向指定位置节点，先让新节点指向pos的后继节点，再让pos指向新节点

（2）完整代码

c 复制代码 
void SLTInsertAfter(SLTNode* pos,SLTDataType x)
{
	assert(pos);
	SLTNode* newnode=SLTBuyNode(x);//申请新节点
	newnode->next=pos->next;//新节点指向指定位置节点
	pos->next=newnode;//pos指向新节点
}

8.删除pos节点

（1）思路

先让pos的前驱节点指向pos的后继节点，再释放pos，最后pos置空

由于这里也会出现pos是头节点的特殊情况，出现这种情况采取分类讨论，直接使用头删方法

（2）完整代码

c 复制代码 
void SLTErase(SLTNode** pphead,SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	if(pos==*pphead)//pos是头节点
	{
		SLTPopFront(pphead);//采用头删
	}	
	else
	{
		SLTNode* prev=*pphead;
		while(prev->next!=pos)//找pos的前驱节点
		{
			prev=prev->next;//prev往后走，继续找
		}
		prev->next=pos->next;//将pos的前驱节点指向后继节点
		free(pos);//释放pos
		pos=NULL;//置空
	}
}

9.删除pos之后的节点

（1）思路

创建临时变量del指向pos的后继节点，pos的后继节点指向del的后继节点（pos的后继节点的后继节点），然后释放del，del置空

（2）完整代码

c 复制代码 
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del=pos->next;//del指向pos的后继节点
	pos->next=del->next;//pos的后继节点指向del的后继节点
	free(del);//释放del
	del=NULL;//del置空
}

七、单链表的打印

c 复制代码 
void STLPrint(SLTNode* phead)
{
	SLTNode* pcur=phead;//定义一个临时指针指向phead
	while(pcur)//判断pcur不为空，也可以写为pcur!=NULL
	{
		printf("%d->",pcur->data);//打印当前节点存储的数据
		pcur=pcur->next;//pcur指向下一个节点
	}
	printf("NULL\n");//最后指向的是NULL
}

八、单链表的销毁

（1）思路

定义一个指针pcur指向头节点，next指针指向pcur的下一个节点，然后销毁pcur指向的节点，再将pcur指向next指向的节点，next往后走，依次不断销毁节点

（2）完整代码

c 复制代码 
void SListDesTory(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur=*pphead;
	while(pcur)//循环结束条件是pcur为空
	{
		SLTNode* next=pcur->next;//next指向pcur的后继节点
		free(pcur);//释放pcur
		pcur=next;
	}
	*pphead=NULL;
}

九、单链表的完整代码

1.Slist.h

c 复制代码 
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//定义节点的结构
typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

void SLTPrint(SLTNode* phead);//打印

void SLTPushBack(SLTNode** pphead, SLTDataType x);//尾插
void SLTPushFront(SLTNode** pphead, SLTDataType x);//头插
void SLPopBack(SLTNode** pphead);//尾删
void SLTPopFront(SLTNode** pphead);//头删
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);//查找
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType);//在指定位置之前插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType);//在指定位置之后插入数据
void SLTErase(SLTNode** pphead, SLTNode* pos);//删除pos节点
void SLTEraseAfter(SLTNode* pos);//删除pos之后的节点
void SListDesTory(SLTNode** pphead);//销毁链表

2.Slist.c

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)
{
	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 SLPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* ptail = *pphead;
		SLTNode* prev = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		prev->next = 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 && *pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}
//在指定位置之后插入数据
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 && *pphead);
	assert(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 SListDesTory(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}
相关推荐
ourenjiang1 小时前
防御式编程
经验分享
lightqjx1 小时前
【算法】数据结构_并查集
数据结构·算法·并查集
数智工坊1 小时前
周志华《Machine Learning》学习笔记--第十一章--特征学习与稀疏学习
笔记·学习·机器学习
喵叔哟1 小时前
第2周学习笔记
笔记·python·学习·langchain
小蒋学算法1 小时前
算法-掉落的方块-线段树
数据结构·算法
Brilliantwxx1 小时前
【算法从零到千】【8-15】滑动窗口
数据结构·算法
Lucis__1 小时前
图的高阶算法：从构造最小生成树到求解最短路径问题
数据结构·c++·算法·图论
数智工坊2 小时前
周志华《Machine Learning》学习笔记--第十二章--计算学习理论
笔记·学习·机器学习
sweetone10 小时前
凯丰KFS-C1迷你电子秤显示不准故障维修
经验分享
热门推荐
01GitHub 镜像站点02【AI】2026 年具身智能模型和世界模型总结032026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf04Codex 下载安装指南：Windows 和 macOS 官方版下载05Codex 桌面端更新后 Chrome 插件和 Computer Use 不可用，怎么排查和修复06CC-Switch 下载、安装与使用配置指南【2026.5.29】07【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法08CC-Switch & Claude 基于 Linux 服务器安装使用指南09Codex 接入 DeepSeek API 完整配置文档10裂开！ChatGPT 居然开始要手机号验证，附详细解决方法