链表及详解

最新推荐文章于 2025-10-30 19:31:01 发布
原创 最新推荐文章于 2025-10-30 19:31:01 发布 · 1k 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构

1.链表

1.1链表的介绍

链表是一种常见的数据结构，用于存储一系列的元素，它与数组不同，链表中的元素不一定是连续存储在内存中的。链表由一系列节点组成，每个节点包含两个部分：数据域和指针域。数据域用来存储数据，而指针域则用来指向下一个节点。链表的最后一个节点的指针域通常指向空（null），表示链表的结束。

1.2链表的主要类型：


1.单链表（Singly Linked List）：每个节点只包含一个指针，指向下一个节点。
2.双链表（Doubly Linked List）：每个节点包含两个指针，一个指向前一个节点，另一个指向下一个节点。
3.循环链表（Circular Linked List）：链表的最后一个节点的指针域指向第一个节点，形成一个环。


1.3链表的主要操作包括：


1.插入：在链表的某个位置插入一个新的节点。
2.删除：从链表中移除某个节点。
3.查找：在链表中查找某个特定值的节点。
4.遍历：按顺序访问链表中的每个节点。
链表的优点在于插入和删除操作不需要移动大量的元素，只需要改变相关节点的指针即可。但是，链表的缺点是访问元素不如数组那样可以直接通过索引快速访问，需要从头节点开始依次遍历到目标节点。此外，链表的每个节点都需要额外的空间来存储指针。
在实际应用中，链表常用于实现栈、队列、哈希表等数据结构，也用于解决某些特定问题，如LRU缓存淘汰算法等。

2.代码的展示

2.1链表的生成及销毁

typedef int SLTINT;
//链表是由节点组成的
typedef struct Linklist//链表                      
{
	SLTINT data;
	struct Linklist* next;

}List;
void LIDestory(List** pphead)
{
	assert(pphead);
	assert(*pphead);


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

2.2链表的初始化

//void Slisttext01()
//{
//	List* node1 = (List*)malloc(sizeof(List));
//	node1->data = 1;
//	List* node2 = (List*)malloc(sizeof(List));
//	node2->data = 2;
//	List* node3 = (List*)malloc(sizeof(List));
//	node3->data = 3;
//	List* node4 = (List*)malloc(sizeof(List));
//	node4->data = 4;
//	node1->next = node2;
//	node2->next = node3;
//	node3->next = node4;
//	node4->next = NULL;
//	List* plist = node1;
//	LIprint(plist);
//}

2.3链表的打印及插入

void LIprint(List* phead)
{
	List* pucr = phead;
	while (pucr)
	{
		printf("%d->", pucr->data);
		pucr = pucr->next;
	}
	printf("NULL\n");
}
//申请空间
List* LIBuynode(SLTINT x)
{
	List* newnode = (List*)malloc(sizeof(List));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
void LIPushBack(List** pphead, SLTINT x)
{
	assert(pphead);
	//链表为空，新节点作为phead
	List* newnode = LIBuynode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}
	
	//链表不为空，找尾节点插入
	List* Pcur = *pphead;
	while (Pcur->next)
	{
		Pcur = Pcur->next;
	}
	//尾节点
	Pcur->next = newnode;
	
}

void LIPushFront(List** pphead, SLTINT x)
{
	assert(pphead);
	//链表为空，找节点作为phead
	List* newnode = LIBuynode(x);

	List* Pcur = *pphead;
	newnode->next = Pcur;
	*pphead = newnode;
	
	//链表不为空，找头节点插入
}

2.4链表的删除

void LIPopBack(List** pphead)
{
	assert(pphead);
	assert(*pphead);
	//链表有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}
	else
	{
		//链表有多个节点
		List* Pcur = *pphead;
		List* prev = NULL;
		while (Pcur->next!=NULL)
		{
			prev = Pcur;
			Pcur = Pcur->next;
		}

		prev->next = NULL;
		//释放尾节点
		free(Pcur);
		Pcur = NULL;
	}
}
//头删
void LIPopFront(List** pphead)
{
	assert(pphead);
	assert(*pphead);
	List* po = (*pphead)->next;
	free(*pphead);
	*pphead = po;
}

2.5链表的指定位置的查找及删除插入

//查找链表
List* LIFind(List** pphead, SLTINT x)
{
	assert(pphead);
	List* pcur = *pphead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}


void LIInsert(List** pphead, List* pos, SLTINT x)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (pos == *pphead)
	{
		LIPushFront(pphead,x);
		return;
	}
	//pos不是头结果的情况
	List* newnode = LIBuynode(x);
	List* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;
}


void LIInsertafter(List* pos, SLTINT x)
{

	assert(pos);
	List* newnode = LIBuynode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}


void LIstrase(List** pphead, List*pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (*pphead == pos)
	{
		//头删
		LIPopFront(pphead);
		return;
	}
	List* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}

void LIstraseafter( List* pos)
{
	assert(pos);
	assert(pos->next);
	List* dit = pos->next;
	pos->next = pos->next->next;
	free(dit);
	dit = NULL;
	
}

3.总代码的展示

.h头文件

#define _CRT_SECURE_NO_WARNINGS 
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLTINT;
//链表是由节点组成的
typedef struct Linklist//链表                      
{
	SLTINT data;
	struct Linklist* next;

}List;
//链表的打印
void LIprint(List* phead);
//链表的尾部插入
void LIPushBack(List** pphead, SLTINT x);
//链表的头部插入
void LIPushFront(List** pphead, SLTINT x);
//链表申请空间
List* LIBuynode(List x);
//链表的尾部删除
void LIPopBack(List** pphead);
//链表的头部删除
void LIPopFront(List** pphead);
//查找链表
List* LIFind(List** pphead, SLTINT x);
//在指定位置之前插入数据
void LIInsert(List** pphead, List* pos, SLTINT x);
//在指定位置之后插入数据
void LIInsertafter(List* pos, SLTINT x);
//删除指定位置的节点
void LIstrase(List* pphead, List* pos);

//删除指定位置之后的节点
void LIstraseafter( List* pos);

//销毁链表
void LIDestory(List** pphead);

.c源代码

#define _CRT_SECURE_NO_WARNINGS 
#include "list.h"
//链表的打印
void LIprint(List* phead)
{
	List* pucr = phead;
	while (pucr)
	{
		printf("%d->", pucr->data);
		pucr = pucr->next;
	}
	printf("NULL\n");
}
List* LIBuynode(SLTINT x)
{
	List* newnode = (List*)malloc(sizeof(List));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
void LIPushBack(List** pphead, SLTINT x)
{
	assert(pphead);
	//链表为空，新节点作为phead
	List* newnode = LIBuynode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}
	
	//链表不为空，找尾节点插入
	List* Pcur = *pphead;
	while (Pcur->next)
	{
		Pcur = Pcur->next;
	}
	//尾节点
	Pcur->next = newnode;
	
}

void LIPushFront(List** pphead, SLTINT x)
{
	assert(pphead);
	//链表为空，找节点作为phead
	List* newnode = LIBuynode(x);

	List* Pcur = *pphead;
	newnode->next = Pcur;
	*pphead = newnode;
	
	//链表不为空，找头节点插入
}

void LIPopBack(List** pphead)
{
	assert(pphead);
	assert(*pphead);
	//链表有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}
	else
	{
		//链表有多个节点
		List* Pcur = *pphead;
		List* prev = NULL;
		while (Pcur->next!=NULL)
		{
			prev = Pcur;
			Pcur = Pcur->next;
		}

		prev->next = NULL;
		//释放尾节点
		free(Pcur);
		Pcur = NULL;
	}
}
//头删
void LIPopFront(List** pphead)
{
	assert(pphead);
	assert(*pphead);
	List* po = (*pphead)->next;
	free(*pphead);
	*pphead = po;
}
//查找链表
List* LIFind(List** pphead, SLTINT x)
{
	assert(pphead);
	List* pcur = *pphead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}


void LIInsert(List** pphead, List* pos, SLTINT x)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (pos == *pphead)
	{
		LIPushFront(pphead,x);
		return;
	}
	//pos不是头结果的情况
	List* newnode = LIBuynode(x);
	List* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;
}


void LIInsertafter(List* pos, SLTINT x)
{

	assert(pos);
	List* newnode = LIBuynode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}


void LIstrase(List** pphead, List*pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (*pphead == pos)
	{
		//头删
		LIPopFront(pphead);
		return;
	}
	List* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}

void LIstraseafter( List* pos)
{
	assert(pos);
	assert(pos->next);
	List* dit = pos->next;
	pos->next = pos->next->next;
	free(dit);
	dit = NULL;
	
}


void LIDestory(List** pphead)
{
	assert(pphead);
	assert(*pphead);


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

测试代码

#include "list.h"
//void Slisttext01()
//{
//	List* node1 = (List*)malloc(sizeof(List));
//	node1->data = 1;
//	List* node2 = (List*)malloc(sizeof(List));
//	node2->data = 2;
//	List* node3 = (List*)malloc(sizeof(List));
//	node3->data = 3;
//	List* node4 = (List*)malloc(sizeof(List));
//	node4->data = 4;
//	node1->next = node2;
//	node2->next = node3;
//	node3->next = node4;
//	node4->next = NULL;
//	List* plist = node1;
//	LIprint(plist);
//}
void Slisttext02()
{
	List* plist = NULL;
	LIPushBack(&plist, 1);
	LIPushBack(&plist, 2);
	LIPushBack(&plist, 3);
	LIPushBack(&plist, 4);
	LIprint(plist);
	LIPopBack(&plist);
	/*LIPopBack(&plist);
	LIPopBack(&plist);
	LIPopBack(&plist);
	LIPopBack(&plist);*/
	//LIPopFront(&plist);
	LIprint(plist);
}
void Slisttext03()
{
	List* plist = NULL;
	LIPushFront(&plist, 1);
	LIPushFront(&plist, 2);
	LIPushFront(&plist, 3);
	LIPushFront(&plist, 4);
	LIprint(plist);
	List*Findet= LIFind(&plist, 2);
	LIInsert(&plist, Findet, 6);
	LIprint(plist);
	List* Findert = LIFind(&plist, 1);
	LIInsertafter(Findert, 66);
	LIprint(plist);
	List* Findrt = LIFind(&plist, 1);
	LIstrase(&plist, Findrt);
	LIprint(plist);

	/*if (Findet)
	{
		printf("找到了！\n");
	}
	else
	{
		printf("没有找到\n");
	}*/
}
int main()
{
//	Slisttext01();
	Slisttext02();
	Slisttext03();
	return 0;
}

寒笙LED
关注
C语言链表操作详解
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
链表的类型
qq_43078445的博客
03-14 3578
1.单链表 所谓的单链表就是链表最基本的结构，链表通过指针将一组零散的内存块串联在一起，其中，我们把内存块称为链表的“节点”。为了所有的节点能串起来，每个链表的节点除了存储数据之外，还需要激励链表上的下一个节点的地址，如图所示，我们把这个记录下个节点的地址的指针叫做后继指针next,如果链表中某个节点为p，p的下一个节点为q，我们可以描述为：p->next=q 下面的图更加详细的描述了单链表...
链表到底是什么？我们应该如何用？
最新发布
2501_93824283的博客
10-30 752
链表（Linked List）就是一个“能连在一起的结构体集合”。数据域（data）→ 存放内容，比如成绩、编号等。指针域（next）→ 指向下一个节点。就像一串火车车厢，每节车厢（节点）都有一根连接下一节车厢的“钩子”（指针）。int data;// 数据部分// 指针部分（指向下一个节点）为了写得更方便，一般用typedefint data;} Node;此时定义一个结构体或结构体指针皆可以直接写成Node head;
单链表的详细讲解
02-28
单链表的详细讲解，学数据结构的内容之一
链表的分类
ywl470812087的博客
04-26 11万+
链表中第一个结点的存储位置叫做头指针，那么整个链表的存取就必须是从头指针开始进行了。之后的每一个结点，其实就是上一个的后继指针指向的位置。 这里有个地方要注意，就是对头指针概念的理解，这个很重要。“链表中第一个结点的存储位置叫做头指针”，如果链表有头结点，那么头指针就是指向头结点数据域的指针。画一个图吧。 头指针就是链表的名字。头指针仅仅是个指针而已。 头结点是为了操作的统一与方便而设立...
轻松搞定面试中的链表题目
计算机的艺术
04-21 6万+
版权所有，转载请注明出处，谢谢！ http://blog.youkuaiyun.com/walkinginthewind/article/details/7393134 链表是最基本的数据结构，面试官也常常用链表来考察面试者的基本能力，而且链表相关的操作相对而言比较简单，也适合考察写代码的能力。链表的操作也离不开指针，指针又很容易导致出错。综合多方面的原因，链表题目在面试中占据着很重要的地位。本文对链
链表的详解
weixin_58867976的博客
02-01 5656
目录 一、单链表
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 22万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
《代码随想录》链表算法详解及实现
09-17
使用场景及目标：本资源涵盖链表理论基础、实践案例和高级技巧等多个层面，可以帮助开发者更好地掌握链表相关的概念，培养解决实际编程难题所需的动手能力和创造性思维。适用于日常工作中遇到的数据结构操作场景，...
数据结构中的链表操作详解：反转与排序的技术实现及应用场景
03-13
内容首先回顾了链表的基本概念与结构，如单向链表、双向链表和循环链表，并详述了插入、删除、查找及遍历等基础操作。然后重点介绍了单向链表和双向链表的反转算法，特别是通过迭代法实现链表的反向重构。此外，文中...
几种链表概念
Zxn、Sirius荣耀之路
03-26 1063
何谓链表？ ：链式存储的线性表，简称链表。链表由多个链表元素组成，这些元素称为节点。结点之间通过逻辑连接，形成链式存储结构。存储结点的内存单元，可以是连续的也可以是不连续的。逻辑连接与物理存储次序没有关系。链表分为两个域： 值域：用于存放结点的值 链域：用于存放下一个结点的地址或位置从内存角度出发： 链表可分为 静态链表、动态链表。 从
链表简介
weixin_26729165的博客
10-10 395
Data structures and algorithms are the foundations to programming. It has become a norm for every interviewer to test on these basics as they provide techniques for handling data efficiently. A progra...
数据结构——链表（超详细解读）
2303_81146519的博客
11-27 3275
链表的详细解读与代码的完整实现
（三）链表分类
qq_27182175的博客
09-29 2411
1.简介 链表作为C语言中的一种基础数据结构，在我们日常开发中用的不多，但是在操作系统里面是随处可见。链表好比一个原型的晾衣架，上面有很多钩子，狗子首尾相连。链表也是，链表由节点(node)组成,节点之间首尾相连。 2.链表分类 2.1单向链表：前一个结点都有一个箭头指向后一个节点，首尾相连，组成一个圈。节点本身必须包含一个节点指针，用于指向下一个节点，同时还可以携带数据 2.2双向链表 3....
c语言实现链表及其基本操作
MBuger的博客
09-13 2万+
链表：        链表是一种物理储存单元上非连续、非顺序的储存结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 和顺序表的区别： 顺序表使用数组存储线形的元素,其特点是可以随机存取,但是,因为逻辑上相邻的元素物理上
数据结构和算法 十、链表的类型
学以致用 知行合一
03-11 1366
链表是一种克服数组限制的数据结构。我们先来看看数组的一些限制 在程序中使用数组之前，必须提前知道数组的大小。 增加数组的大小是一个耗时的过程。在运行时扩展数组的大小几乎是不可能的。 数组中的所有元素都需要连续存储在内存中。在数组中插入一个元素需要转移它的所有前辈。 链表很有用，因为 它动态分配内存。链表的所有节点都非连续地存储在内存中，并在指针的帮助下链接在一起。 在链表中，大小不再是问题，因为我们不需要在声明时定义它的大小。列表根据程序的需求增长并限制在可用内存空间内。
链表详细解析
qq_63137068的博客
04-09 427
hello，小伙伴们，大家好，本期讲解的是关于基础链表创建和应用 所谓链表其实是指针和结构体组成的一种链式数组，那么链表的作用是什么呢，链表的作用是用来插入数的（注意这点，是插入数而不是覆盖整），之前做过关于插入数组的题，当时是用两个数组，用第二个数组一直来覆盖第一个数组写的，但是明显效率不高而且很烂的感觉。
C语言复杂链表复制详解及实现
本文将深入解析C语言中复杂链表的复制过程。复杂链表是一种特殊的链表结构，每个节点包含数据域、指向下一个节点的指针以及随机指向链表中其他节点或空节点的指针。复杂链表的数据结构定义如下： ```c typedef int ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值