C语言单链表

灵晔君2026-06-20 13:07

C语言单链表

我们之前学习顺序表 （数组实现的线性表）时，发现它有几个致命缺陷：

  1. 头插/中间插入删除效率极低：每次操作都要挪动后面全部数据，时间复杂度 O（N）
  2. 扩容有开销还可能造成空间浪费：顺序表一般 2 倍扩容，提前开辟一大片空间，后续用不完就会闲置（如果扩容了200个字节空间，实际只有101字节数据，将会浪费掉99个字节空间）

那有没有一种结构，能做到头部增删O（1） 、按需分配内存、不存在空间浪费 ？

单链表可以做到

文章目录

  • C语言单链表
    • 一、单链表的概念
      • [1、 单链表是什么？](#1、 单链表是什么？)
      • [2、 结构体定义结点](#2、 结构体定义结点)
      • [3、 单链表优缺点](#3、 单链表优缺点)
    • [二、 基础封装](#二、 基础封装)
      • [1、创建新结点 SLTbuyNode](#1、创建新结点 SLTbuyNode)
      • [2、 打印整条链表SLTPrint](#2、 打印整条链表SLTPrint)
    • [三、 链表基本操作](#三、 链表基本操作)
      • [1、 前置知识：一级指针 & 二级指针](#1、 前置知识：一级指针 & 二级指针)
      • [2、 头插 SLTPushFront（时间复杂度O(1)）](#2、 头插 SLTPushFront（时间复杂度O(1)）)
      • [3、 尾插 SLTPushBack（时间复杂度O(N)）](#3、 尾插 SLTPushBack（时间复杂度O(N)）)
      • [4、头删 SLTPopFront（时间复杂度O(1)）](#4、头删 SLTPopFront（时间复杂度O(1)）)
      • [5、 尾删 SLTPopBack（时间复杂度O(N)）](#5、 尾删 SLTPopBack（时间复杂度O(N)）)
      • [6、 查找 SLTFind](#6、 查找 SLTFind)
      • [7、 在 pos 节点之前插入 SLTInsertO(N)）](#7、 在 pos 节点之前插入 SLTInsertO(N)）)
      • [8、 在 pos 节点之后插入 SLTInsertAfterO(1)](#8、 在 pos 节点之后插入 SLTInsertAfterO(1))
      • [9、 删除 pos 节点 SLTErase O(N)](#9、 删除 pos 节点 SLTErase O(N))
      • [10、 删除 pos之后的节点 SLTEraseAfterO(1)](#10、 删除 pos之后的节点 SLTEraseAfterO(1))
      • [11、 内存释放：销毁整条链表 SListDestroy](#11、 内存释放：销毁整条链表 SListDestroy)
    • [四、 测试代码演示（test.c）](#四、 测试代码演示（test.c）)
    • [五、 完整代码](#五、 完整代码)

一、单链表的概念

1、 单链表是什么？

单链表也是一种数据结构 ， 由无数个结点存储数据 ，并通过指针 将结点串联起来。一列火车就像一个单链表，每个火车车厢都是一个结点。

  • 单链表的逻辑结构是线性的（数据有先后顺序）
  • 单链表的物理结构是非线性的，非连续且随机分散在堆内存中（假设堆内存是一个空房间，结点出现在房间的哪个位置都是有可能的，结点地址毫无规律）
  • 链表的最小单元是结点 ，单链表的结点有两个部分，一个是存储数据 （data ），另一个是存下一个结点的内存地址 （next），用于找到下一个元素
  • 最后一个结点存储的内存地址（next）必须置为NULL，代表链表结束

2、 结构体定义结点

我们新建头文件 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; //将结点结构体重命名为SLTNode

3、 单链表优缺点

优点

  1. 按需分配内存：需要几个节点就开辟几块内存，不存在顺序表的空间浪费
  2. 头部增删效率极高：头插、头删时间复杂度 O(1)，完美解决顺序表头操作慢的痛点

缺点

  1. 随机访问不支持 ：无法像数组一样arri直接取值，想访问第 n 个元素必须从头遍历，O(N)

  2. 尾插、指定位置前插入、删除都需要遍历链表，效率低

  3. 每个节点额外存储next指针，存在少量内存开销

二、 基础封装

1、创建新结点 SLTbuyNode

每次增删节点都要开辟内存，把这个过程封装成函数，复用代码

c 复制代码 
#define _CRT_SECURE_NO_WARNINGS
#include"SList.h"

//为新生成的值为x的新节点，开辟一块内存，返回结点地址
SLTNode* SLTbuyNode(SLTDateType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");	//	内存开辟失败打印错误
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;	//新节点默认是尾部，next置空
	return newnode;
}

2、 打印整条链表SLTPrint

打印链表必然要涉及到遍历 ，遍历时将会引入一个头指针phead，这是第一个结点的地址

遍历逻辑：从头指针开始，打印当前节点数据，再通过next指针跳转到下一个结点，再打印当前节点数据，循环往复，直到NULL停止

c 复制代码 
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;//用cur遍历指针，不改动原头指针
	while (pcur != NULL)
	{
		printf("%d -> ", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");	//末尾标记链表结束
}

三、 链表基本操作

1、 前置知识：一级指针 & 二级指针

假如我们在main函数里写：SLTNode * plist = NULL; （plist是头指针变量）

plist（一级指针）变量 ：存结点地址，类型SLTNode*

&plist（二级指针）：取 plist 这个指针变量自己的内存地址，类型SLTNode**

为什么有的函数要二级指针？

  1. 只传一级指针（SLTNode * phead）------ 拷贝，改不动外面
  • 函数接收的只是plist地址的副本 （形参），函数里修改phead = xxx，只会改副本，main 里原 plist （实参）纹丝不动。
  • 举个反例：如果尾插只用一级指针，空链表时phead = newnode根本没用，外面 plist 还是 NULL。
  • 适用场景：只读取链表、不修改头指针本身（打印、查找、pos 后插入、删除 pos 后结点）
  1. 传二级指针（SLTNode ** pphead）------ 能修改外部原指针
  • 我们把&plist传进去，形参pphead保存了 plist 变量的地址 。函数里写 * pphead = newnode，等价于在 main 里写 plist = newnode，直接修改外部的头指针。
  • 适用场景：会改变链表头部的操作（头插、空链表尾插、头删、删完链表变空、pos 前插入、删除 pos 结点）。

只要操作会改变链表头节点，函数参数必须用二级指针！

2、 头插 SLTPushFront（时间复杂度O(1)）

在链表最前面插入节点，不用遍历

  1. 新建节点
  2. 新节点next指向原来的头节点
  3. 更新头指针，让头指针指向新节点
c 复制代码 
void SLTPushFront(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);	//防止传入空二级指针
	SLTNode* newnode = SLTbuyNode(x);
	newnode->next = *pphead;	//新节点衔接原链表
	*pphead = newnode;	//头指针更新为新节点
}

3、 尾插 SLTPushBack（时间复杂度O(N)）

在链表末尾插入节点，需要遍历找到最后一个节点 ，分两种情况：

  1. 链表为空（ * pphead == NULL）：直接把头指针赋值为新节点
  2. 链表有节点：循环找到尾节点（ptail->next == NULL），尾节点next指向新节点
c 复制代码 
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTbuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//遍历找尾结点
		SLTNode* ptail = *pphead;
		while (ptail->next != NULL)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;	//找到之后把新结点插到末尾
	}
}

4、头删 SLTPopFront（时间复杂度O(1)）

删除第一个节点：

  1. 保存第二个节点地址
  2. free 释放原头节点
  3. 更新头指针为保存的第二个节点
c 复制代码 
void SLTPopFront(SLTNode** pphead)
{
	//断言：二级指针不为空。且链表不为空
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

5、 尾删 SLTPopBack（时间复杂度O(N)）

删除最后一个节点，必须找到倒数第二个节点 ，两种条件：

  1. 链表只有 1 个节点：直接 free 头节点，置空
  2. 多个节点：遍历保存前驱节点prev，找到尾节点后，prev->next = NULL再释放尾节点
c 复制代码 
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 != NULL)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}

6、 查找 SLTFind

遍历链表，匹配目标值，返回对应节点地址。找不到返回NULL

c 复制代码 
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur != NULL)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

7、 在 pos 节点之前插入 SLTInsertO(N)）

已知某节点pos，在它前面插新节点

  • 特殊情况：pos是头节点，直接复用头插
  • 普通情况 ：遍历找到pos的前驱prev，完成链接：prev→newnode→pos
c 复制代码 
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && 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;
	}
}

8、 在 pos 节点之后插入 SLTInsertAfterO(1)

不需要找前驱，直接衔接，效率极高！

链接顺序不能写反（不然会找不到下一个结点）

  1. 新节点next先接住pos原本的下一个节点
  2. 再让pos->next指向新节点
c 复制代码 
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTbuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

9、 删除 pos 节点 SLTErase O(N)

删除指定地址的节点：

  • 特殊：pos 是头节点，复用头删
  • 普通：找到前驱prev，跳过 pos 节点，free 释放内存
c 复制代码 
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && 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;
	}
}

10、 删除 pos之后的节点 SLTEraseAfterO(1)

不用遍历，直接跳过后一个节点释放

c 复制代码 
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

11、 内存释放：销毁整条链表 SListDestroy

  • 链表所有节点都在堆上开辟，程序结束前必须全部 free，否则内存泄漏。
  • 遍历过程中先保存下一个节点地址，再释放当前节点，最后头指针置空。
c 复制代码 
void SListDestroy(SLTNode** pphead)
{
	SLTNode* pcur = *pphead;
	while (pcur != NULL)
	{
		SLTNode* next = pcur->next;//提前存下一个结点
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;//头指针置空防止野指针
}

四、 测试代码演示（test.c）

c 复制代码 
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include"SList.h"

void test01()
{
	SLTNode* plist = NULL;
	// 尾插 1 2 3 4
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist); // 1 -> 2 -> 3 -> 4 -> NULL

	// 头插 0
	SLTPushFront(&plist, 0);
	SLTPrint(plist); // 0 -> 1 -> 2 -> 3 -> 4 -> NULL

	// 查找值为4的节点
	SLTNode* find = SLTFind(plist, 4);
	// 在4前面插入100
	SLTInsert(&plist, find, 100);
	SLTPrint(plist); // 0 -> 1 -> 2 -> 3 -> 100 -> 4 -> NULL

	// 在4后面插入200
	SLTInsertAfter(find, 200);
	SLTPrint(plist); // 0 -> 1 -> 2 -> 3 -> 100 -> 4 -> 200 -> NULL

	// 删除4这个节点
	SLTErase(&plist, find);
	SLTPrint(plist); // 0 -> 1 -> 2 -> 3 -> 100 -> 200 -> NULL

	// 销毁链表，释放全部内存
	SListDestroy(&plist);
}

int main()
{
	test01();
	return 0;
}

五、 完整代码

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; //将结点结构体重命名为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);

2、SList.c

c 复制代码 
#define _CRT_SECURE_NO_WARNINGS
#include"SList.h"

//为新生成的值为x的新节点，开辟一块内存，返回结点地址
SLTNode* SLTbuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");	//	内存开辟失败打印错误
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;	//新节点默认是尾部，next置空
	return newnode;
}

void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;//用cur遍历指针，不改动原头指针
	while (pcur != NULL)
	{
		printf("%d -> ", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");	//末尾标记链表结束
}


void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);	//防止传入空二级指针
	SLTNode* newnode = SLTbuyNode(x);
	newnode->next = *pphead;	//新节点衔接原链表
	*pphead = 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 != NULL)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;	//找到之后把新结点插到末尾
	}
}

void SLTPopFront(SLTNode** pphead)
{
	//断言：二级指针不为空。且链表不为空
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

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 != NULL)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur != NULL)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && 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;
}

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && 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;
	}
}

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 != NULL)
	{
		SLTNode* next = pcur->next;//提前存下一个结点
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;//头指针置空防止野指针
}
热门推荐
012026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？022026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？032026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf04【AI】2026 年具身智能模型和世界模型总结05GitHub 镜像站点06AI科技热点日报 | 2026年6月1日07AI一周事件 · 2026-06-03 至 2026-06-09082026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？09Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析10上线仅72小时被强制下架：Claude Fable 5 的短命