链表：概念解析与C语言代码实现

关注

原创 2026-05-02 16:45:13 742 阅读 AI 写同款· GEO 优化 ›

数据结构学习指南：从概念到代码实践，构建立体知识体系 数据结构是计算机科学的核心基础，它研究数据的组织、存储和操作方式，是算法设计与程序优化的基石。其核心原理在于通过逻辑结构（如线性表、树、图）描述数据关系，并通过物理存储结构（如顺序、链式）在计算机内存中实现。掌握数据结构的技术价值在于能够显著提升程序运行效率与资源利用率，是解决复杂计算问题、进行系统性能优化的关键。在应用场景上，从数据库索引（B树）、网络路由（图算法）到编译器设计（栈）、缓存系统（队列），数据结构无处不在。本文以严蔚敏经典教材为蓝本，通过重构知识框架与提供可运行的C语言代码，特别是针对链表操阅读详情

一、前言

前几篇博客里介绍了顺序表这种数据结构。

顺序表：概念解析与C语言代码实现-优快云博客

基于顺序表实现通讯录项目-优快云博客

用双指针法解决两道顺序表基础算法题（LeetCode 27 & 88）-优快云博客

而顺序表虽然可以方便地完成增删查改等操作，却也存在不足：

1、中间、头部的插入删除，涉及到移动数据，比较麻烦。

2、增容需要申请新的空间、拷贝数据、释放旧空间，会有不小的性能消耗。

3、增容一般是呈2倍的增长，势必会有一定的空间浪费。

为了解决以上问题，我们引入了另一种数据结构“链表”。

本文会详细介绍链表的概念和代码实现。

二、链表的概念

链表和顺序表一样，也是线性表的一种。链表在逻辑结构上是线性的，而在物理结构上不是线性的。

链表由一个一个的节点组成。每个节点由两部分组成，一是这个节点存储的数据，二是指向下一个节点的指针。

那么我们只需定义每个节点的结构，把它们连接起来就可以形成链表了。根据上面的描述我们可以知道，我们定义的表示的节点结构体应该有两个成员：（以存储整型数据为例）一个整型数据data和一个指向下一个节点的结构体指针。

理解了链表的概念，接下来我们就可以着手写代码去实现它了。

三、代码实现

3.1 创建文件

SList.h用来定义节点结构体和链表的各种功能，SList.c用来实现各种功能，test.c用来测试。

3.2 定义节点结构体

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

//定义节点的结构
typedef struct SListNode
{
	int data;
	struct SListNode* next;
}SLTNode;

创建好这个结构体，我们在test.c文件中用它来创建一个链表。

我们创建四个节点，它们的指针分别是node1、node2、node3、node4。我们用malloc给这四个节点分别开辟一块空间，在四个节点里分别放入1、2、3、4这四个整型数据。

最后我们让每个节点中的结构体指针成员指向下一个节点，就得到了一个完整的链表。

//test.c
void SListTest01()
{
	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 1;

	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
	node2->data = 2;

	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
	node3->data = 3;

	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
	node4->data = 4;

	//将四个节点连接起来
	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;
}

int main()
{
	SListTest01();
}

3.3 功能实现

3.3.1 打印链表

由于实现和测试后续功能的过程中我们肯定需要频繁打印链表的内容，所以我们在此处写一个函数来实现打印链表的功能。

void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

此处我们创建了一个临时的指针变量pcur，让它顺着链表移动，就可以打印出链表的所有元素了。

测试一下。

我们创建一个指向头结点的指针变量，把它传给SLTPrint。

3.3.2 尾部插入

现在我们实现的各种功能都以int类型数据为例。为了使链表能够存储更多类型的数据，我们使用typedef将int类型重新定义为SLTDataType，这样以后一次修改，全局生效。

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

现在我们来实现尾部插入功能。

我们只需创建一个新的节点，找到尾节点，让尾结点中的结构体指针指向新节点，就完成了尾插。

我们此时意识到“创建一个新的节点”在后续的操作中肯定是一个常见的操作。所以我们把它拎出来，专门写一个函数来实现这个功能。

SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc failed!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

现在我们可以用这个函数来实现尾插功能了。

需要特别注意的是，此处我们想用形参改变实参，需要传址调用，函数的参数应该为二级指针。

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
    assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	SLTNode* ptail = *pphead;
	while (ptail->next != NULL)
	{
		ptail = ptail->next;
	}
	ptail->next = newnode;
}

此处还需要注意，链表可能为空，此时phead为空指针，那么上述代码中对ptail解引用的语句就会报错。所以我们需要将这种情况拎出来专门讨论。

这种情况下我们只需创建一个新节点，然后让phead指向这个新节点即可。完整的代码如下：

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;
	}
}

测试一下这个功能：

3.3.3 头部插入

我们只需创建一个新的节点，让新节点中的next指向现有链表的头结点，再让新的节点成为头结点即可。如果操作的链表为空，那么就把新节点中的next直接置为空，不需要特别处理。

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

测试一下：

3.3.4 尾部删除

这里需要分成“链表只有一个节点”和“链表有两个及以上的节点”两种情况来考虑。

当链表只有一个节点的时候，我们只需用free将这一个节点释放即可。

当链表有多个节点的时候，我们需要先用循环找到最后一个节点和倒数第二个节点，将最后一个节点释放，将倒数第二个节点的next置为空。

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* prev = *pphead;
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		prev->next = NULL;
	}
}

测试一下这个功能：

3.3.5 头部删除

我们只需要将第一个节点释放即可。但是如果直接释放，我们就无法找到第二个节点的位置。所以我们要创建一个临时变量，存储一下第二个节点的地址。

void SLTPopFront(SLTNode** pphead)
{
	//链表不能为空
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

考虑一下链表只有一个元素的情况：此时上述代码依然适用，不需要特别处理。

测试一下：

3.3.6 查找

我们只需遍历链表中的所有元素，找到需要查找的数据后返回其节点的指针，没找到返回NULL即可。

此处我们只是要查找数据，不需要改变链表，所以传参传一级指针就好。

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

测试一下：

3.3.7 指定位置之前插入

这个函数需要三个参数：链表头结点的二级指针、指定位置的地址、需要插入的数据。

首先我们用SLTBuynode创建一个新的节点。

然后我们需要找到指定位置的前一个节点，让这个节点的next指向新节点，再让新节点的next指向指定位置的节点，这样我们就把一个新的节点插入到了指定位置的前面。

按照上面的思路我们可以写出以下代码：

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);

	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	newnode->next = pos;
	prev->next = newnode;
}

但此时我们考虑一下特殊情况：

如果指定位置就是链表的头节点，那么prev和pos都指向头结点。prev->next不等于pos，prev往后走一个节点；此时prev->next仍然不等于pos，prev继续往后走一个节点。就这样循环，当prev走到最后一个节点的时候，会出现对空指针的解引用，代码报错。这显然无法满足我们的需求。

所以我们需要单独处理这种情况。在头结点之前插入数据，我们只要调用一下头部插入的函数即可。修改后的代码如下：

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);

	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}

测试一下：

测试在头结点前面插入数据的特殊情况：

3.3.8 指定位置之后插入

在指定位置之后插入数据，我们只需要两个参数：指定位置的地址和要插入的数据。

为什么不需要头结点的二级指针了呢？

刚才的指定位置之前插入，我们需要找到指定位置之前的节点。我们无法从指定位置向前找到它的前一个节点，因此需要从头节点开始找。

但是要找指定位置的后一个节点是很方便的，我们只需要用一下指定位置节点的next就可以了。所以在指定位置之后插入数据，我们用不到头结点的二级指针。

那么接下来着手实现这个功能。

我们只需调用SLTBuyNode创建一个新的节点，然后让指定位置节点的next指向新节点，让新节点的next指向指定位置之后的节点即可。

需要注意的是，如果我们先改变指定位置节点的next，就找不到原来链表中排在指定位置之后的节点了。所以我们要先改变新节点的next，再让指定位置节点的next指向指定位置之后的节点。

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

考虑一下特殊情况：如果指定位置是原链表的最后一个节点，上述代码依然适用，不需要特别处理。

测试一下：

3.3.9 指定位置删除

这个函数需要两个参数：头结点的二级指针（因为我们需要寻找指定位置的前一个节点）和指定位置。

我们只需让指定位置前一个节点的的next指向指定位置后一个节点，再把指定位置的节点释放掉即可。

考虑特殊情况：和头部删除时遇到的问题一样，如果指定位置就是头结点，需要特别处理。

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;
	}
}

测试一下：

3.3.10 指定位置之后删除

实现指定位置之后删除的时候，如果我们直接让指定位置节点的next指向要删除的节点的下一个节点，就找不到要删除的那个节点的地址了。所以我们要设置临时变量。

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

测试一下：

3.3.11 销毁链表

销毁链表时要从头结点开始，顺着链表一个节点一个节点往后删除。

在删除每个节点的时候，要注意用临时变量保存一下下一个节点的地址，否则删除当前节点后就找不到下一个节点了。

最后要把指向头结点的指针置为空。

void SListDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);

	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

测试一下：

现在我们已经实现了链表的全部功能。

从以上这些功能的实现过程中我们可以看出，链表与顺序表相比，插入数据时不需要移动数据，也不需要用realloc扩容，进而避免了浪费空间的问题以及realloc所带来的性能消耗。不过，链表也有缺陷：它无法通过下标来随机访问。顺序表适合元素高效存储和频繁访问，链表则适用于需要在任意位置频繁插入和删除的场景。两者是“互补”的数据结构。

END

收录于