数据结构：链表（C语言实现）

最新推荐文章于 2025-07-08 18:14:30 发布
最新推荐文章于 2025-07-08 18:14:30 发布
阅读量5.1k 收藏 40
点赞数 6
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构 链表 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44740544/article/details/89784501
本文介绍了线性表、数组与链表的关系，线性表分为顺序表和链表。着重讲解了链表，它在逻辑上连续，物理上不一定连续，通过指针连接。详细阐述了单向链表和双向链表的结构定义、初始化、插入、删除等基本操作，还提及判断循环链表、偶数结点反转等特殊操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

介绍链表之前，我们还需要了解一下线性表、数组与链表的关系。

线性表是一种线性结构，它的特点是在数据元素的非空有限集中：

  • 存在唯一的一个被称作“第一个”的数据元素
  • 存在唯一的一个被称作“最后一个”的数据元素
  • 除第一个外，集合中的每个数据元素均只有一个前驱
  • 除最后一个外，集合中每个数据元素均只有一个后继

简单来谈就是数据元素“一个接一个的排列”，且由同一种类型的数据元素构成的线性结构就是线性表。而线性表又分为两种，顺序表和链表。

顺序表正如其名，是线性表的顺序存储结构，又被常称为向量（vector）如下图： 线性表的顺序储存结构
数据元素在内存的位置是相邻的，而顺序表的其中一种表达形式便是数组。

线性表的链式存储结构——链表

不同于顺序表，链表在逻辑上是连续的，但在物理上不一定是连续的，而是通过指针完成每个内存空间的连接。在这里插入图片描述
链表在内存空间上不连续，为反映出各元素在线性表中的前后关系，除了存储元素本身的信息外，还需添加一个或多个指针域（如上图的next域）。指针域的值叫指针，又称作链，它用来指示数据元素的存储首址。这两部分信息一起组成一个数据元素的存储映像，称存储映像为结点。上图中，head叫这个链表的头指针，指向链表的第一个结点，头指针是链表的必要元素，无论链表是否为空，头指针都不为空。

当链表的第一个节点的数据域无意义时，则这个结点叫做头节点，根据头节点存在与否，可将链表分为有头链表与无头链表，一般情况下，有头链表的数据域可存放链表的长度。上图为有头链表。

而链表还有另一种分法，将链表分为单向链表（上图）、双向链表与循环链表。

单向链表

单向链表是最简单的链表形式，只能单向遍历，下面我们用C语言来实现无头结点单向链表的基本操作

结构定义

我们将结点定义成一个结构来表示，其中里面的数据类型用ElemType表示

// define element type
typedef int ElemType; 

// define struct of linked list
typedef struct LNode { 
	ElemType data; 
  	struct LNode *next; 
} LNode, *LinkedList;

// define Status
typedef enum Status { 
	ERROR,
	SUCCESS
} Status;
初始化

传入初始化接口的参数是链表的头指针（二级指针），事实上形参和实参分配的内存空间并不相同，如果说在这里传入的是一个一级指针，那么当调用这个接口时，会另外申请一个空间做指针，就不是拿原来的实参做操作了。使用二级指针能保证传入接口的是我们要操作的指针。

/**
 *  @name        : Status InitList(LinkList *L);
 *	@description : initialize an empty linked list with only the head node without value
 *	@param		 : L(the head node)
 *	@return		 : Status
 *  @notice      : None
 */
Status InitList(LinkedList *L)
{
	*L = (LinkedList)malloc(sizeof(LinkedList));		//给第一个结点申请空间
	if(!(*L))											//若申请失败返回错误
		return ERROR;
	(*L)->next = NULL;
	return SUCCESS;
}
摧毁链表
/**
 -  @name        : void DestroyList(LinkedList *L)
 - @description : destroy a linked list, free all the nodes
 - @param		 : L(the head node)
 - @return		 : None
 -  @notice      : None
 */
void DestroyList(LinkedList *L)
{
	LinkedList p;
	while(*L){
		p = (*L)->next;
		free(*L);
		*L = p;
	}
}
插入

插入方式分为前插法和后插法（下图），后插法更符合平常思维方式在这里插入图片描述

/**
 -  @name        : Status InsertList(LNode *p, LNode *q)
 - @description : insert node q after node p
 - @param		 : p, q
 - @return		 : Status
 -  @notice      : None
 */
Status InsertList(LNode *p, LNode *q)
{
	if(!p)					//如果p结点不存在，返回错误
		return ERROR;
	q->next = p->next;
	p->next = q;
	return SUCCESS;
}
删除

这里我们要把即将删除的结点数据储存到指针e所指向的内存空间，需要注意的是，在调用这个接口前，要给指针e赋予一个指向的内存空间，这也是新手们（包括我）经常犯的错误，导致q->data的数据没有内存空间存放而报错。
解决办法有：

  • 在传入指针之前，malloc一块内存空间
  • 传入ElemType变量的地址
/**
 *  @name        : Status DeleteList(LNode *p, ElemType *e)
 *	@description : delete the first node after the node p and assign its value to e
 *	@param		 : p, e
 *	@return		 : Status
 *  @notice      : None
 */
Status DeleteList(LNode *p, ElemType *e)
{
	if(!p && !p->next)
		return ERROR;
	LNode *q;
	q = p->next;
	*e = q->data;		//记得调用前检查e是否有指向一个已知的内存空间
	p->next = q->next;
	free(q);
	return SUCCESS;
}
遍历

遍历就没什么要讲的了，循环一次print一次数据数据

/**
 *  @name        : void TraverseList(LinkedList L, void (*visit)(ElemType e))
 *	@description : traverse the linked list and call the funtion visit
 *	@param		 : L(the head node), visit
 *	@return		 : None
 *  @notice      : None
 */
void TraverseList(LinkedList L, void (*visit)(ElemType e))
{
	LNode *p;
	p = L;
	while(p){
		visit(p->data);
		p = p->next;
	}
}

/**
 *  @name        : void visit(ElemType e)
 *	@description : print e
 *	@param		 : e
 *	@return		 : None
 *  @notice      : None
 */
void visit(ElemType e)
{
	printf("%d ",e);
}
搜索

其实和遍历的方法接近，经过遍历去比较数据中是否有e的值

/**
 *  @name        : Status SearchList(LinkedList L, ElemType e)
 *	@description : find the first node in the linked list according to e
 *	@param		 : L(the head node), e
 *	@return		 : Status
 *  @notice      : None
 */
Status SearchList(LinkedList L, ElemType e)
{
	LNode *p;
	p = L;
	while(p){
		if(p->data == e)
			return SUCCESS;
		else
			p = p->next;
	}
	return ERROR;
}
反转

反转的话比较有意思，它是通过定义三个指针——前中后，实现反转。中指针将指针指向前一个结点，前指针表示中指针的前一个结点，后指针原在中指针的下一个结点，用于控制前中指针往后移动。

/**
 *  @name        : Status ReverseList(LinkedList *L)
 *	@description : reverse the linked list
 *	@param		 : L(the head node)
 *	@return		 : Status
 *  @notice      : None
 */
Status ReverseList(LinkedList *L)
{
	if(!(*L) && !(*L)->next)
		return ERROR;
	LNode *pre, *cur, *Next;		//定义前中后三个指针
	pre = *L;
	cur = (*L)->next;				//先将第一个结点的指针域指向NULL
	pre->next = NULL;
	while(cur){
		Next = cur->next;			//后指针后移
		cur->next = pre;			//将中间的指针指向前一个结点
		pre = cur;					//前中指针后移
		cur = Next;
	}
	*L = pre;						//头指针指向“原尾结点”
	return SUCCESS;
}
判断是否为循环链表

单向链表和双向链表的尾结点指针域都指向了NULL，而循环链表的尾结点指针域却指向了第一个结点，如果对循环链表遍历的话如果没有限制次数，遍历不会停止。在这里插入图片描述
判断一个链表是否为循环链表也很简单，可以运用初高中“环形操场追及问题”的方法来解决，定义一个快指针和一个慢指针，通过循环，让快指针每次走两个结点，慢指针每次走一个结点，如果是循环链表，那总有一个时间会让两个指针出现在相同的位置（除开始点外的第一次相等）

/**
 *  @name        : Status IsLoopList(LinkedList L)
 *	@description : judge whether the linked list is looped
 *	@param		 : L(the head node)
 *	@return		 : Status
 *  @notice      : None
 */
Status IsLoopList(LinkedList L)
{
	LNode *fast, *slow;
	fast = slow = L;				//快慢指针在相同起点
	while(fast && fast->next){
		slow = slow->next;			//slow走一个结点
		fast = fast->next->next;	//fast走两个结点
		if(slow == fast)
			return SUCCESS;
	}
	return ERROR;
}
偶数结点反转

eg：1->2->3->4->5 变成 2->1->4->3->5
类似的反转就叫偶数结点反转，解决这个问题关键在分两类讨论：结点个数为奇数、结点个数为偶数。

/**
 *  @name        : LNode* ReverseEvenList(LinkedList *L)
 *	@description : reverse the nodes which value is an even number in the linked list, input: 1 -> 2 -> 3 -> 4  output: 2 -> 1 -> 4 -> 3
 *	@param		 : L(the head node)
 *	@return		 : LNode(the new head node)
 *  @notice      : choose to finish
 */
LNode* ReverseEvenList(LinkedList *L)
{
	LNode *pre, *cur, *Next;		//定义前中后指针，用途和反转相似
	pre = *L;
	*L = pre->next;
	while(pre && pre->next){
		cur = pre->next;
		Next = cur->next;
		if(cur->next && cur->next->next){			//如果cur->next不存在，结点个数为偶数
			pre->next = cur->next->next;			//如果cur->next->next不存在，结点个数为奇数
		}else{										//如果都存在，遍历未结束
			pre->next = cur->next;
		}
		cur->next = pre;							//将偶数结点反转
		pre = Next;
	}
	return *L;
}
搜索中间结点

搜索中间结点就是遍历两次，第一次计算结点个数，找出第几个结点是中间结点，第二次就是抓出中间结点的位置了

/**
 *  @name        : LNode* FindMidNode(LinkedList *L)
 *	@description : find the middle node in the linked list
 *	@param		 : L(the head node)
 *	@return		 : LNode
 *  @notice      : choose to finish
 */
LNode* FindMidNode(LinkedList *L)
{
	LNode *mid = *L;
	int cnt;
	for(cnt=0; mid; cnt++)
		mid = mid->next;
	mid = *L;
	for(int i=0; i<cnt/2; i++)
		mid = mid->next;
	return mid;
}

双向链表

双向链表区别于单向链表的地方在于一个结点有两个指针域，一个指向后节点，一个指向前结点，优势也比较明显，比如要计算链表中最后一次出现数字1的位置，单向链表需要先遍历一次找到第X个结点出现最后一次数字1，再遍历找到该结点位置，而双向链表可以直接从末尾开始遍历，可以大大节省搜索时间，然而缺点就是比单向链表占内存。
在这里插入图片描述

结构定义

和单向链表没什么差别，只是在结构中多出来一个指向前结点的指针

// define element type
typedef int ElemType;

// define struct of linked list
typedef struct DuLNode {
	ElemType data;
  	struct DuLNode *prior,  *next;
} DuLNode, *DuLinkedList;

// define status
typedef enum Status {
	ERROR,
	SUCCESS,
} Status;

双向链表的基本操作与单向链表相差不大，这里我就将代码一起发上来。

基本操作
/**
 *  @name        : Status InitList_DuL(DuLinkedList *L)
 *	@description : initialize an empty linked list with only the head node
 *	@param		 : L(the head node)
 *	@return		 : Status
 *  @notice      : None
 */
Status InitList_DuL(DuLinkedList *L)
{
	*L = (DuLinkedList)malloc(sizeof(DuLinkedList));
	if(!(*L))
		return ERROR;
	(*L)->next = NULL;
	(*L)->prior = NULL;
	return SUCCESS;
}

/**
 *  @name        : void DestroyList_DuL(DuLinkedList *L)
 *	@description : destroy a linked list
 *	@param		 : L(the head node)
 *	@return		 : status
 *  @notice      : None
 */
void DestroyList_DuL(DuLinkedList *L)
{
	DuLinkedList p;
	while(*L){
		p = (*L)->next;
		free(*L);
		*L = p;
		if(p)
			p->prior = NULL;
	}
}

/**
 *  @name        : Status InsertBeforeList_DuL(DuLNode *p, LNode *q)
 *	@description : insert node q before node p
 *	@param		 : p, q
 *	@return		 : status
 *  @notice      : None
 */
Status InsertBeforeList_DuL(DuLNode *p, DuLNode *q)
{
	if(!p)
		return ERROR;
	if(p->prior){
		p->prior->next = q;
		q->prior = p->prior;
	}
	q->next = p;
	p->prior = q;
	return SUCCESS;
}

/**
 *  @name        : Status InsertAfterList_DuL(DuLNode *p, DuLNode *q)
 *	@description : insert node q after node p
 *	@param		 : p, q
 *	@return		 : status
 *  @notice      : None
 */
Status InsertAfterList_DuL(DuLNode *p, DuLNode *q)
{
	if(!p)
		return ERROR;
	if(p->next){
		p->next->prior = q;
		q->next = p->next;
	}
	q->prior = p;
	p->next = q;
	return SUCCESS;
}

/**
 *  @name        : Status DeleteList_DuL(DuLNode *p, ElemType *e)
 *	@description : delete the first node after the node p and assign its value to e
 *	@param		 : p, e
 *	@return		 : status
 *  @notice      : None
 */
Status DeleteList_DuL(DuLNode *p, ElemType *e) {
	if(!p && !p->next)
		return ERROR;
	DuLNode *q;
	q = p->next;
	*e = q->data;
	q->next->prior = p;
	p->next = q->next;
	free(q);
	return SUCCESS;
}

/**
 *  @name        : void TraverseList_DuL(DuLinkedList L, void (*visit)(ElemType e))
 *	@description : traverse the linked list and call the funtion visit
 *	@param		 : L(the head node), visit
 *	@return		 : Status
 *  @notice      : None
 */
void TraverseList_DuL(DuLinkedList L, void (*visit)(ElemType e)) {
	DuLNode *p;
	p = L;
	while(p){
		(*visit)(p->data);
		p = p->next;
	}
}

/**
 *  @name        : void visit(ElemType e)
 *	@description : print e
 *	@param		 : e
 *	@return		 : None
 *  @notice      : None
 */
void visit(ElemType e)
{
	printf("%d ",e);
}

双向循环链表只是第一个节点的prior指针指向最后一个结点，最后一个结点的next指针指向第一个结点，其它与上述差别不大。这里就不展开叙述了。

参考：

  1. 算法与数据结构（C语言版） 主编·邓玉洁
  2. 数据结构：链表https://blog.youkuaiyun.com/juanqinyang/article/details/51351619
C语言数据结构-链表
2302_81072215的博客
11-26 1858
图中指针变量plist保存的是第一个结点的地址，我们称plist此时“指向”第一个结点，如果我们希望plist“指向”第二个结点时，只需要修改plist保存的内容为0x0012FFA0.在前面说的单链表中的“头结点”，该头结点是链表的首节点（第一个结点），实际这样的称呼是错误的，因为链表中存在一种链表叫做带头链表（不是指链表里第一个有效的结点），这里的头结点指的是，在这里直接使用plist来遍历结果也是一样的，重新创建个pcur指针，是为了避免由于指针指向的改变，导致无法重新找到链表的首结点。
数据结构：链表（删除，C语言实现）
Jareanger的博客
02-08 683
这里的current相当于是要被删除的节点的前驱的地址，current->next相当于是待删除节点的地址，current->next->next相当于是待删除节点的后继的地址，我们要做的首先是把待删除节点（也就是NODE index）的内存给释放掉，然后把之前已经存储在next变量中的current->next->next赋值给current->next，也就是把前驱和后继连接起来，这样就好了。注意，由于要释放内存，因此要先把后继的地址current->next->next存储到新的变量里面再进行操作。
数据结构c语言——链表
2302_79340870的博客
04-09 665
【代码】数据结构c语言。
数据结构-链表
最新发布
Kongxl64的博客
07-08 858
**删除指定节点 (Delete a specific node)**：遍历链表找到要删除节点的前一个节点，修改其 `next` 指针，跳过要删除的节点。* **在链表头部插入 (Insert at the beginning)**：创建一个新节点，使其 `next` 指向原头节点，然后更新头节点指向这个新节点。数组的随机访问速度是O(1)，而链表是O(n)。6. **`deleteAt(int index)` (删除):** 根据索引找到要删除的节点的前一个节点，修改指针实现删除。
数据结构之链表（C语言）
谁以何定义完美
05-13 2451
链表是一种、非顺序的存储结构，数据元素的是通过链表中的次序实现的。链表有两个储存区，第一个储存区，第二个储存区储存1.2链表的分类链表可通过以下组合分类为八种。
数据结构链表详解（c语言实现）
qq_44053320的博客
11-05 6815
链表（C语言）绪论单链表的实现单链表的定义单链表的初始化单链表的插入删除单链表的删除单链表的查找单链表的修改单链表的建立双向链表循环链表链表与顺序表的区别总结 绪论 线性表是数据结构中比较常见也比较重要的一种线性结构。简言之，线性表是n个数据元素的有限序列。而线性表又有两种常见的实现方式，其中比较常考的就是链表了。 链表实现顺序表的时候，与顺序表最大不同之处在于，链表中两个逻辑位置在一起的元素，物理地址并不连续，因为链表的每个会有一个指向下一项的指针，指针所指地址对应的值才是与该元素逻辑上相邻的值。本文我们
【数据结构】链表-C语言版
局部变量和全局变量
01-17 775
顺序表缺点 顺序表随机访问很方便，但是也会有不足啊： （1）挪动数据时间开销较大：头部/中间的插入删除，需要挪动后面的所有数据，时间复杂度为O(N) （2）增容有代价：增容需要重新申请空间，拷贝数据，释放旧空间，系统消耗不小 （3）空间浪费：增容一般增至原来的2倍大空间，会有空间浪费，假如当前容量为100，满了以后增容到200，再继续插入了5个数据，后面没有插入数据了，这就浪费了95个空间。 不存在扩容代价、不存在空间浪费、按需申请空间、头部或者中间插入数据而不需要挪动数据的链表可以解决以上问
《算法与数据结构》第三章：线性表-静态链表C语言实现
12-10
在《算法与数据结构》中，第三章主要探讨了线性表的静态链表结构以及其在C语言中的实现方法。线性表是一种常见的基础数据结构，它可以被实现为数组或者链表。静态链表是链表的一种特殊形式，与动态链表相比，它通常...
数据结构：基于C语言的图书管理系统.zip
08-02
《数据结构：基于C语言的图书管理系统》是一个典型的IT项目，它结合了计算机科学中的核心概念——数据结构和编程语言C，旨在让学生或开发者实践如何用C语言来设计和实现一个实际的应用系统。这个课程设计的目标是...
数据结构：链表（创建与初始化，C语言实现）
Jareanger的博客
02-05 1195
链表是顺序表的升级版，它的存储空间是不连续，因此在进行删除，插入操作的时候，不需要像顺序表一样把后面的所有元素进行前移覆盖，因此更加方便，下面我们首先用代码来创建一个链表。一个结构体的节点由它存储的内容以及一个指向下一个结点的指针组成，可以把整个链表理解为一个打了很多结的绳子，一个节点由一个绳结和两段绳结之间的绳子组成，绳结就是数据域，即存储的数据内容，中间的绳子就是指针，连接两个不同的节点。
数据结构 -＞链表（C语言实现）
weixin_58666778的博客
11-17 939
链表的概念链表的实现总体思路尾插新节点的建立尾删头插头删查找其余接口所有代码SList.hSList.c 链表的概念 1.官方的概念 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 2.我的总结： 链表就是一个可变的数据存储表，可以在他的基础上增删查改。不用像顺序表那样频繁增容，也不会浪费空
(C语言数据结构)单链表
09-16
C语言实现单链表 Init(初始化) Length(当前结点个数) AddEnd(尾部添加) AddFirst(首部添加) Insert(插入) * Delete(删除) Find(查找返回) ShowAll(显示所有元素) Destory(销毁链表)
c语言数据结构之单链表
xingweiyong的专栏
11-11 1934
本教程会在以后持续公布c语言数据结构的实现文章，一来重温一下基础知识，二来为正在学习此部分内容的同学提供参考和思路，教程内容均来自于书籍、网友分享和本人思考，侧重代码编写和实现，详细的理论论述还是要翻阅经典的书籍，在此感谢贡献自己智慧的广大编程人员。今天的主题是单链表，这是一种非常常见的数据结构，隶属于线性表，是一种简单的链式实现方式，文中会实现我们在面试中经常会碰见的【单链表反转】的问题。链表为了
数据结构与算法——用C语言实现链表的初始化、增加节点、删除节点、查找节点等
weixin_44132627的博客
04-05 1772
最近自己学习了线性表的链式表示和实现，其相关概念在《数据结构》——严蔚敏，教材中有详细的介绍。该篇文章主要是利用c语言中的结构、指针等知识来实现链表的增、删、查、找的功能。 一 、 首先，链表中每个节点可定义为以下结构形式，如下： typedef int Type; // 用Type代替 int， 方便修改数据类型 // 定义一个结构体类型，为一个链表节点 t...
c语言实现数据结构中的链表源代码
u014574317的博客
03-23 1万+
#include #include typedef struct LNode *List; struct LNode { int data; List next; }; struct LNode L; List InitList(List PtrL) { PtrL = (List) malloc(sizeof(L)); PtrL->next = NULL; return PtrL
[数据结构]单链表C语言的简单实现
一起来书写我们的青春
11-30 2543
单链表的C语言实现
【数据结构】单链表的c语言实现
热门推荐
只鱼
05-18 1万+
单链表的c语言实现 文章目录单链表的c语言实现定义单链表结构体初始化单链表操作头插法创建单链表尾插法创建单链表计算单链表的长度获取单链表中元素新元素插入单链表删除链表中某元素单链表的整表删除打印出整个单链表 链表是通过一组任意的存储单元来存储线性表中的数据元素，这些存储单元可以是连续的也可以是不连续的。为了建立起数据元素之间的关系，对于每个数据元素除了存放数据元素自身的信息外，还必须有包含的指示...
数据结构_单链表的实现(C语言)附源码
m0_65592409的博客
04-22 2464
目录 *链表的表示与实现* 前言 子函数 定义结构体 main函数 1.插入元素 2.打印链表 3.头插法 ​​ 4.尾插法 5.链表是否为空 6.删除元素 7.清空单链表 8.销毁单链表 9.单链表初始化 10.获取链表长度 11.获取链表元素 12.查找元素位置 源代码 *链表的表示与实现* 前言 本文章以C语言的链表操作实现单链表的表示与实现，基本各种数据结构已具备，但并未完善代码的可读性及完善性，有兴趣的读者可以进行修改。 ...
数据结构和算法3:重要的链表
weixin_42278523的博客
07-21 164
1. 链表是什么？ 顺序表的缺点 添加和删除操作需要移动元素。 当数据量特别大的情况，可能没有连续的内存可使用。 链表，别名链式存储结构或单链表，用于存储逻辑关系为 “一对一” 的数据。与顺序表不同，链表不限制数据的物理存储状态。顺序表通过连续的地址建立元素之间前后连接关系，链表通过指针方式建立元素之间前后连接关系。 2. 链表怎么用？ 链表用法与顺序表相似，只是适用场景有所不同。 3. 链表如何实现 3.1 定义结构 使用链表存储的数据元素，其物理存储位置是随机的。数据元素随机存储，并通过指针表
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值