数据结构——链表

最新推荐文章于 2024-09-28 15:33:25 发布
最新推荐文章于 2024-09-28 15:33:25 发布
阅读量582 收藏 8
点赞数 7
分类专栏： 数据结构初阶 文章标签： 数据结构 链表 c语言 开发语言 C++ c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CptGhost/article/details/142498904
版权

【本节内容】

1.链表

1.链表的概念及结构

概念：链表是一种 物理存储结构上非连续、非顺序的存储结构，数据元素的 逻辑顺序是通过链表中的 指针链接次序实现的 。
就像我们一节一节的小火车一样，靠中间的链子链接在一起。

现实中 数据结构中
 

1.2 链表的分类


实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：


1. 单向或者双向
 

2. 带头或者不带头
 

3. 循环或者非循环
 

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：
 

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。
 

1、无头+单向+非循环链表增删查改实现

SList.h

#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 SLPushFront(SLTNode** pphead, SLTDataType x);//头插
void SLPushBack(SLTNode** pphead, SLTDataType x);//尾插
void SLPopFront(SLTNode** pphead);//头删
void SLPopBack(SLTNode** pphead);//尾删
void SLErase(SLTNode** pphead, SLTNode* pos);// 删除pos位置的值
void SLInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);//在pos位置插入
SLTNode* STFind(SLTNode* phead, SLTDataType x);//查找与x值相同的节点位置

SList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Slist.h"
void SLTPrint(SLTNode* phead)//打印链表
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

SLTNode* BuyLTNode(SLTDataType x)//初始化节点
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

void SLPushFront(SLTNode** pphead, SLTDataType x)//头插
{
	SLTNode* newnode = BuyLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SLPushBack(SLTNode** pphead, SLTDataType x)//尾插
{
	SLTNode* newnode = BuyLTNode(x);
	// 1、空链表
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	// 2、非空链表
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SLPopFront(SLTNode** pphead)//头删
{
	// 判空
	assert(*pphead);
	SLTNode* del = *pphead;
	*pphead = (*pphead)->next;
	free(del);
}

void SLPopBack(SLTNode** pphead)//尾删
{
	assert(*pphead);
	// 一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	// 多个节点
	else
	{
		SLTNode* tail = *pphead;
		// 找尾
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

SLTNode* STFind(SLTNode* phead, SLTDataType x)//查找与x值相同的节点位置
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

void SLInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)//在pos位置插入
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SLPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuyLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

void SLErase(SLTNode** pphead, SLTNode* pos)// 删除pos位置的值
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
	}
}


test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
int main()
{
	SLTNode* plist = NULL;
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 4);
	SLPushFront(&plist, 0);
	SLPopBack(&plist);
	SLPopFront(&plist);
	SLTNode* pos = STFind(plist, 1);
	SLErase(&plist, pos);
	SLTPrint(plist);
	return 0;
}

运行结果：

 

2.双向链表：

DList.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;

LTNode* LTInit();//初始化双向链表
void LTPrint(LTNode* phead);//打印双向链表
bool LTEmpty(LTNode* phead);//判断链表是否为空
void LTPushBack(LTNode* phead, LTDataType x);//双向链表尾插
void LTPushFront(LTNode* phead, LTDataType x);//双向链表头插
void LTPopBack(LTNode* phead);//双向链表尾删
void LTPopFront(LTNode* phead);//双向链表头删
LTNode* LTFind(LTNode* phead, LTDataType x);//查找与x值相同的节点
void LTInsert(LTNode* pos, LTDataType x);// 在pos位置插入
void LTErase(LTNode* pos);// 删除pos位置的值
void LTDestroy(LTNode* phead);//销毁双向链表

DList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"DList.h"
LTNode* BuyLTNode(LTDataType x)//初始化节点
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

LTNode* LTInit()//初始化双向链表
{
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

void LTPrint(LTNode* phead)//打印双向链表
{
	assert(phead);
	printf("guard<==>");
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<==>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

bool LTEmpty(LTNode* phead)//判断双向链表是否为空
{
	assert(phead);
	return phead->next == phead;
}

void LTPushBack(LTNode* phead, LTDataType x)//双向链表尾插
{
	assert(phead);
	LTInsert(phead, x);
}

void LTPushFront(LTNode* phead, LTDataType x)//双向链表头插
{
	LTInsert(phead->next, x);
}

void LTPopBack(LTNode* phead)//双向链表尾删
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTErase(phead->prev);
}

void LTPopFront(LTNode* phead)//双向链表头删
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTErase(phead->next);
}

LTNode* LTFind(LTNode* phead, LTDataType x)//查找与x值相同的节点
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}


void LTInsert(LTNode* pos, LTDataType x)// 在pos位置插入
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

void LTErase(LTNode* pos)//删除pos位置的值
{
	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

void LTDestroy(LTNode* phead)//销毁双向链表
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "DList.h"
int main()
{
	LTNode* plist = LTInit();
	printf("%d\n",LTEmpty(plist));
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushBack(plist, 5);
	LTPushBack(plist, 6);
	LTPopFront(plist);
	LTPopBack(plist);
	LTNode* pos = LTFind(plist,2);
	LTErase(pos);
	LTPrint(plist);
	LTDestroy(plist);
	return 0;
}

运行结果：

 

PS：看到这里了，码字不易，给个一键三连鼓励一下吧！有不足或者错误之处欢迎在评论区指出！

Le-Code
关注
专栏目录
数据结构 —— 链表
Labrador_Katie的博客
08-28 1125
链表线性表链表的分类单向链表双向链表循环链表 线性表 线性表：由零个或多个数据元素组成的有限序列。 线性表有两种存储方式： 顺序存储结构——即数组 链式存储结构——即链表 线性表强调： 它是一个序列，元素之间有个先来个后到； 若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他元素有且只有一个前驱和后继； 线性表强调是有限的。 链表的分类 单向链表 单向链表是最简单的链表形式。我们将链表中最基本的数据称为节点(node)，每一个节点包含了数据块和指向下一个节点的指针。 特点：用一组任意的存储
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
算法与数据结构——链表
qq_47917118的博客
03-18 343
链表 存储结构 顺序存储:地址连续，用数组 链式存储:地址不连续，用指针(引用，面向对象) 链表 链表中的每一个元素称为“结点”，单链表中每个结点都应包括两个部分：一个是需要用到的实际数据data；另一个就是存储下一个结点地址的指针，即数据域和指针域；而双向链表中，每个结点包括存储其上一个结点地址的指针，用到的数据data和存储下一个结点的指针。数据结构中的每一个数据结点对应于一个存储单元，这种储存单元称为储存结点，也可简称结点。 ———————————————— data为实际存放的数据，next为存
数据结构——链表OJ题
Renswc的博客
02-20 3564
链表oj题练习，链表尾插，我们可以用一个tail指针来记录尾插后的节点，尾插直接在tail节点后即可，这样就不用每次尾插都循环遍历，大大减少了时间复杂度 ，提高了运行效率。
C语言数据结构——链表
热门推荐
zcxmjw的博客
12-22 1万+
大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。
数据结构——链表（Linked List）
jishuxhengjiu的博客
08-31 1万+
使用单向环形链表解决Josephu问题，用不带头结点的单向循环链表先构成一个有n个节点的链表，然后由k节点起从1开始计数，直到第m时，对应节点删除，然后从被删除的下一个节点开始从1开始计数，直到最后一个节点被删除结束算法。2.temp.next = temp.next.next，也就是说需要删除节点的前一个节点本来指向的是删除节点，然后我们使其指向删除节点的下一个节点，直接跳过删除节点，这样该节点也就相当于被删除了。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。1.单链表是以节点的方式来存储的。.
golang数据结构——链表
lp15929801907的博客
03-10 1543
golang链表详解
数据结构——链表(java)
薯条和番茄酱的博客
01-03 4391
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
数据结构——链表 Ⅰ
luoin9399的博客
11-02 2365
一、基本认识 1.定义：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 2. 优点： ①插入和删除不必改变其他元素，只需改变指针，复杂度O（1）； ②不用像数组一样需要预先知道数据大小，链表结构可以充分利用计算机内存空间； 3.缺点： ①查找结点或访问结点效率低，需要O（n）的时间..
数据结构——链表（C语言版）
2302_80657849的博客
05-05 928
我们只介绍了很简单的链表知识，也只截取了一些有意思的题目。以上便是今天的全部内容。如果有帮助到你，请给我一个免费的赞。因为这对我很重要。编程世界的小比特，希望与大家一起无限进步。
算法和数据结构——链表.pdf
08-07
在标题《算法和数据结构——链表.pdf》中提到的“算法”指的是对数据的处理过程和步骤，而“数据结构”是指数据在计算机中的组织方式，二者在计算机科学中是基础且核心的概念。在数据结构的学习中，链表是实现算法的...
数据结构——链表的实现
12-29
在这个数据结构——链表的实现中，我们将深入探讨如何用C++来创建一个链表类，并实现搜索、删除、插入和查找等基本操作。 首先，链表的基本思想是使用节点（或称为元素）来存储数据，每个节点包含两部分：数据域和...
数据结构——链表的创建、插入、删除.pdf
08-07
链表是一种基础的数据结构，特别适用于那些插入、删除操作频繁的场景，它的核心优势在于动态性，即能在运行时动态地调整存储空间的大小。 链表由一系列节点构成，每个节点分为两个部分：数据域和指针域。数据域用于...
数据结构：树、森林
pranaa的博客
09-24 1021
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
【嵌入式软件-数据结构与算法】01-数据结构
最新发布
零碎小杂铺
09-28 978
摘录于老师的教学课程~~(*๓´╰╯`๓)~~内含链表、队列、栈、循环队列等详细介绍~~
数据结构：串 及串的模式匹配（KMP）
pranaa的博客
09-23 1180
串（String）是由零个或多个字符组成的有限序列，又名叫字符串。在计算机科学中，串是一种重要的数据结构，用于表示文本数据。串中的元素称为字符，字符可以是字母、数字或其他符号，这些字符可以是任意字符集中的成员。串是许多编程语言中的基本数据类型，用于处理文本数据。
数据结构讲解二叉树 【一】
2401_85388078的博客
09-25 1189
在数据结构中，二叉树作为步入实现复杂结构的门栏，为后续的图，排序衔接紧密，因此我将详细讲解二叉树，初定分为三至五篇文章讲解。文章干货满满，还请您细细品读，如果您觉得作者写得不错，抑或对您有所帮助，不妨给俺点个免费的赞和玩玩呢？关注作者不迷路，后续将有更多原创内容更新哟点点点点点点点点点点点点。
【初阶数据结构】排序——插入排序
2301_77112794的博客
09-25 578
本文讲解了插入排序，包括直接插入排序和希尔排序
数据结构与算法分析——链表表示与信息处理
数据结构不仅包括数据的逻辑结构（如链表、数组），还包括物理结构（如内存布局）以及与这些结构相关的操作（如插入、删除、查找）。 1.1节中提到了数据结构的重要性，指出良好的数据结构能够提高算法的效率。例如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值