【数据结构】线性表之链表

news2025/1/20 14:48:16

目录

  • 前言
  • 一、链表的定义
  • 二、链表的分类
    • 1. 单向和双向
    • 2. 带头和不带头
    • 3. 循环和不循环
    • 4. 常用（无头单向非循环链表和带头双向循环链表）
  • 三、无头单向非循环链表的接口及实现
    • 1. 单链表的接口
    • 2. 接口的实现
  • 四、带头双向循环链表接口的及实现
    • 1. 双向链表的接口
  • 2. 接口的实现
  • 五、带头双向循环链表VS无头单向非循环链表
    • 1. 带头双向循环链表
      • 1.1 带头双向循环链表的优点：
      • 1.2 带头双向循环链表的缺点：
    • 2. 无头单向非循环链表
      • 2.1 无头单向非循环链表的优点：
      • 2.2 无头单向非循环链表的缺点：
    • 3. 小结
  • 六、链表VS顺序表
    • 1. 带头双向循环链表
      • 1.1 链表的优点：
      • 2. 链表的缺点：
    • 2. 顺序表
      • 2.1顺序表的优点
      • 2.2顺序表的缺点
  • 结尾

前言

上一篇文章讲述了线性表中的顺序表，这篇文章讲述关于链表的定义、类别、实现、多种不同链表的优缺点和链表与顺序表的优缺点。
关于上一篇文章的链接：线性表之顺序表

一、链表的定义

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

在这里插入图片描述

二、链表的分类

1. 单向和双向

在这里插入图片描述

在这里插入图片描述

2. 带头和不带头

在这里插入图片描述
在这里插入图片描述

3. 循环和不循环

在这里插入图片描述
在这里插入图片描述

4. 常用（无头单向非循环链表和带头双向循环链表）

在这里插入图片描述

在这里插入图片描述

三、无头单向非循环链表的接口及实现

1. 单链表的接口

#pragma once
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

// slist.h
typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
// 单链表的销毁
void SListDestroy(SListNode* plist);

2. 接口的实现

#include "slist.h"

SListNode* BuySListNode(SLTDateType x)
{
	//创造新节点
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return NULL;
	}
	//新节点初始化
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

void SListPushBack(SListNode** pplist, SLTDateType x)
{
	//这里使用二级指针的原因是：
	//若链表为空，需要改变的就是结构体指针，需要结构体指针的地址
	//若传入的是一级指针，这里传入的只是临时拷贝，无法改变函数外的变量
	if (*pplist == NULL)
	{
		*pplist = BuySListNode(x);
	}
	//若不为空，需要改变的是结构体，只需要结构体的指针
	else
	{
		SListNode* tail = *pplist;
		SListNode* newnode = BuySListNode(x);
		while (tail->next)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}

}

void SListPrint(SListNode* plist)
{
	while (plist)
	{
		printf("%d->", plist->data);
		plist = plist->next;
	}
	printf("NULL");
}

void SListPushFront(SListNode** pplist, SLTDateType x)
{
	//这里使用二级指针的原因是：每次头删都需要改变头节点
	SListNode* newnode = BuySListNode(x);
	
	newnode->next = *pplist;
	*pplist = newnode;
}

//无头单链表尾删删除节点的时候有三种情况
void SListPopBack(SListNode** pplist)
{
	//没有节点
	assert(*pplist);

	//一个节点
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	//多个节点
	else
	{
		//尾删既可以找尾找尾的前一个节点，也可以创造一个变量记录尾节点的前一个节点

		//创造一个变量记录尾节点的前一个节点
		//	SListNode* tail = *pplist;
		//	SListNode* prev = NULL;
		//	while (tail->next)
		//	{
		//		prev = tail;
		//		tail = tail->next;
		//	}

		//	free(prev->next);
		//	prev->next = NULL;
		
		//找尾找尾的前一个节点
		SListNode* tail = *pplist;
		while (tail->next->next)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

//无头单链表头删删除节点的时候有三种情况，但只有一个节点和多个节点的情况可以合并
void SListPopFront(SListNode** pplist)
{
	//无节点时
	assert(*pplist);
	
	//有节点时
	SListNode* del = *pplist;
	*pplist = del->next;
	free(del);
}

SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	SListNode* cur = plist;
	while (cur)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	//断言：在pos后面插入一个节点，最差的情况是pos为尾节点，但不能为NULL
	assert(pos);
	SListNode* cur = (SListNode*)malloc(sizeof(SListNode));
	if (cur == NULL)
	{
		perror("malloc");
		return;
	}
	cur->data = x;
	cur->next = pos->next;
	pos->next = cur;
}

void SListEraseAfter(SListNode* pos)
{
	//需要删除节点的前一个节点不能为NULL，删除节点也不能为NULL
	assert(pos);
	assert(pos->next);
	
	SListNode* next = pos->next;
	pos->next = next->next;
	free(next);
}

void SListDestroy(SListNode* plist)
{
	SListNode* del = NULL;
	while (plist)
	{
		del = plist;
		plist = plist->next;
		free(del);
	}
}

四、带头双向循环链表接口的及实现

1. 双向链表的接口

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

2. 接口的实现

#include "list.h"

// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
	if (phead == NULL)
	{
		perror("malloc");
		return NULL;
	}

	//让头的 next 和 prev 都指向自己
	//则双向链表为空
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

// 创造新节点
ListNode* BuyTLNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return NULL;
	}

	newnode->data = x;

	return newnode;
}

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	/*ListNode* tail = pHead->prev;
	ListNode* newnode = BuyTLNode(x);
	
	newnode->next = pHead;
	newnode->prev = tail;
	tail->next = newnode;
	pHead->prev = newnode;*/
	ListInsert(pHead, x);   //复用
}

// 双向链表打印
void ListPrint(ListNode* pHead)
{
	printf("header <--> ");

	//打印的时候，由于头内的 data 的值没用
	//则从头的的下一个节点开始打印
	//并且在循环到头的时候打印结束
	ListNode* cur = pHead ->next;
	while (cur != pHead)
	{
		printf("%d <--> ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

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

// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	assert(!(LTEmpty(pHead)));

	/*ListNode* first = pHead->next;
	ListNode* second = first->next;
	pHead->next = second;
	second->prev = pHead;

	free(first);*/
	ListErase(pHead->next);   //复用
}

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	/*ListNode* next = pHead->next;
	ListNode* newnode = BuyTLNode(x);
	
	newnode->next = next;
	newnode->prev = pHead;
	next->prev = newnode;
	pHead->next = newnode;*/
	ListInsert(pHead->next, x);//复用
}

// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);               
	assert(!(LTEmpty(pHead)));
	/*ListNode* tail = pHead->prev;
	ListNode* tailPrev = tail->prev;

	tailPrev->next = pHead;
	pHead->prev = tailPrev;

	free(tail);*/

	ListErase(pHead->prev); //复用
}

// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	ListNode* cur = pHead ->next;

	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}


// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newnode = BuyTLNode(x);
	ListNode* posPrev = pos->prev;

	newnode->next = pos;
	newnode->prev = posPrev;
	posPrev->next = newnode;
	pos->prev = newnode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);

	ListNode* posPrev = pos->prev;
	ListNode* posNext = pos->next;

	posPrev->next = posNext;
	posNext->prev = posPrev;

	free(pos);
}

五、带头双向循环链表VS无头单向非循环链表

1. 带头双向循环链表

1.1 带头双向循环链表的优点：

  1. 可以自由地在链表中任意位置插入和删除节点，这是因为双向链表可以方便地找到前驱和后继节点。
  2. 可以支持双向遍历，即可以从前往后或从后往前遍历链表。
  3. 可以更加高效地实现某些特殊的操作，比如在链表中删除指定节点，需要同时修改其前驱和后继节点的指针，双向链表则可以直接完成这个操作，而单向链表则需要遍历到前驱节点才能完成。

1.2 带头双向循环链表的缺点：

  1. 因为每个节点都要额外存储一个前驱节点的指针，所以需要更多的内存空间。
  2. 因为需要维护前驱和后继节点的指针，所以在插入和删除节点时需要更多的操作，导致时间复杂度较高。

2. 无头单向非循环链表

2.1 无头单向非循环链表的优点：

  1. 因为每个节点只需存储一个后继节点的指针，所以需要较少的内存空间。
  2. 在插入和删除节点时，只需要修改前一个节点的指针，不需要修改后一个节点的指针，操作相对简单，导致时间复杂度较低。

2.2 无头单向非循环链表的缺点：

  1. 无法实现双向遍历，即无法从后往前遍历链表。
  2. 在删除指定节点时，需要先遍历到其前驱节点，才能完成删除操作，导致删除效率较低。

3. 小结

总之，选择哪种链表数据结构应该根据具体的应用场景和需要做的操作来决定。如果需要频繁地插入和删除节点，且需要支持双向遍历，可以选择带头双向循环链表；如果需要占用较少的内存空间，且不需要双向遍历，可以选择无头单向非循环链表。

六、链表VS顺序表

1. 带头双向循环链表

1.1 链表的优点：

  1. 动态内存分配：链表可以在运行时动态地分配内存，因此可以根据实际需要灵活地增加或减少节点数。
  2. 插入和删除操作高效：由于链表中的元素不必在连续的内存空间中存储，所以插入和删除操作非常高效，只需要修改指针，而不需要移动所有后续元素。
  3. 大小不受限制：链表的大小不受限制，可以根据实际需要进行扩展。

2. 链表的缺点：

  1. 随机访问低效：由于链表中的元素不是按顺序存储的，因此随机访问某个元素的效率比较低，需要从头开始遍历O(N)。
  2. 存储空间开销大：链表每个节点都需要额外的指针来指向下一个节点，这样会增加存储空间的开销。
  3. 缓存不友好：由于链表中的元素不是按顺序存储的，因此可能会导致缓存未命中，降低访问效率。

2. 顺序表

2.1顺序表的优点

  1. 随机访问高效：下标的随机访问效率高O(1)。
  2. 尾删尾插高效：顺序表的尾插尾删不需要移动数据，效率高。
  3. 缓存友好：由于链表中的元素是按顺序存储的，缓存命中率高，访问效率高。

2.2顺序表的缺点

  1. 部分插入删除操作低效：由于顺序表中的元素是物理结构上是连续的，当数据插入删除前面顺序表的时候需要移动数据，效率低O(N)。
  2. 内存大小受限：当顺序表内存存满后需要扩容，扩容需要代价，并且顺序表通常会有内存的浪费情况。

结尾

如果有什么建议和疑问，或是有什么错误，希望大家能够提一下。
希望大家以后也能和我一起进步！！
如果这篇文章对你有用的话，希望能给我一个小小的赞！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/532170.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

磺酸基-Cy5 羧酸Sulfo-Cy5 COOH分子式C32H37N2KO8S2

磺酸基-Cy5 羧酸Sulfo-Cy5 COOH分子式C32H37N2KO8S2

Sulfo CY5 COOH是一种有机化合物&#xff0c;属于荧光染料。它具有荧光、稳定、水溶性等特点&#xff0c;因此被应用于分析化学、生物技术、药物研发等领域。Sulfo CY5 COOH的分子式为C32H37N2KO8S2&#xff0c;分子量为680.87。它的荧光波长为670nm&#xff0c;可以通过荧光显…
阅读更多...
如何在AD中添加自定义材料单模板

如何在AD中添加自定义材料单模板

AD默认的材料单格式和常用的格式有点区别&#xff0c;为了减少在材料单格式编辑的工作&#xff0c;决定添加自定义模板到AD的模板中。 1.查找AD模板的安装位置 在AD菜单Reports中&#xff0c;找到“Bill of materials”菜单&#xff0c; 点击后&#xff0c;弹出的窗口中包含了…
阅读更多...
Kubernets1.20部署Redis7.0集群6节点三主三从（完整版）-2023.5.13

Kubernets1.20部署Redis7.0集群6节点三主三从（完整版）-2023.5.13

目录 一、产品选型二、草图三、部署1、安装NFS服务1&#xff09;NFS Server端安装NFS2&#xff09;创建NFS 共享点3&#xff09;启动rpcbind、nfs服务4&#xff09;验证服务配置 2、创建持久卷PVC1&#xff09;创建ServiceAccount账号2&#xff09;创建provisioner3&#xff09…
阅读更多...
vite入坑之路：react+vite动态导入报错@vite-ignore的解决方法

vite入坑之路：react+vite动态导入报错@vite-ignore的解决方法

正常的动态组件导入方式 webpack搭建的项目&#xff0c;不管是react还是vue通常引入动态组件基本这么写&#xff1a; const url import(../pages/${locale}) // vite不支持or const url import(../pages/${locale}/index.jsx) // vite不支持这在vite架构中&#xff0c;一般…
阅读更多...
Vue3+vite环境变量配置

Vue3+vite环境变量配置

在项目开发中&#xff0c;通常来说&#xff0c;不同的环境会有不同的请求api接口&#xff0c;这就需要修改配置&#xff0c;才能满足对应的环境。所以这里就使用了环境变量。环境变量就是在不同的环境中使用不同的变量值。 # 环境变量文件(.env) 在项目根目录&#xff08;和sr…
阅读更多...
TCP协议和相关特性

TCP协议和相关特性

1.TCP协议的报文结构 TCP的全称为&#xff1a;Transmission Control Protocol。 特点: 有连接可靠传输面向字节流全双工 下面是TCP的报文结构&#xff1a; 源端口和目的端口&#xff1a; 源端口表示数据从哪个端口传输出来&#xff0c;目的端口表示数据传输到哪个端口去。…
阅读更多...
FPGA_学习_03_第一个FPGA程序流水灯

FPGA_学习_03_第一个FPGA程序流水灯

学习编程&#xff0c;最重要永远就是动手&#xff0c;本文将在开发板上实现FPGA的“Hello world”→流水灯。本文主要目的是熟悉在Vivado上从零到程序运行起来的基本开发流程。 1 硬件电路介绍 本人购买的开发板接在PL端的只有2个LED灯&#xff0c;刚好达到流水灯的最低要求。…
阅读更多...
今年这情况，大家多一手准备吧......

今年这情况，大家多一手准备吧......

大家好&#xff0c;最近有不少小伙伴在后台留言&#xff0c;又得准备面试了&#xff0c;不知道从何下手&#xff01; 不论是跳槽涨薪&#xff0c;还是学习提升&#xff01;先给自己定一个小目标&#xff0c;然后再朝着目标去努力就完事儿了&#xff01; 为了帮大家节约时间&a…
阅读更多...
ASEMI代理MAX5048BAUT+T原装ADI车规级MAX5048BAUT+T

ASEMI代理MAX5048BAUT+T原装ADI车规级MAX5048BAUT+T

编辑&#xff1a;ll ASEMI代理MAX5048BAUTT原装ADI车规级MAX5048BAUTT 型号&#xff1a;MAX5048BAUTT 品牌&#xff1a;ADI /亚德诺 封装&#xff1a;SOT-23-6 批号&#xff1a;2023 安装类型&#xff1a;表面贴装型 引脚数量&#xff1a;6 工作温度:-40C~125C 类型&a…
阅读更多...
npx下载构建nuxt3开发模板失败的解决方案

npx下载构建nuxt3开发模板失败的解决方案

在搭建nuxt3项目开发的时候&#xff0c;安装nuxt3开发模板的时候&#xff0c;使用命令&#xff1a; npx nuxi init my-app 会出出现一下错误&#xff1a; This is related to npm not being able to find a file. 发生上述错误是因为您有一个未正确安装的依赖项。 以下是解决…
阅读更多...
大央企的“中央厨房”，泰裤辣

大央企的“中央厨房”，泰裤辣

本文来源&#xff1a;特大号 作者&#xff1a;特大妹 最近两年&#xff0c;大央企大国企在数字化转型中&#xff0c;特热衷成立“中央厨房”。 有的中央厨房&#xff0c;单独挂牌为“数科公司”&#xff0c;有的中央厨房&#xff0c;升级为集团数字化转型的一级部门。 把之前各…
阅读更多...
“警”彩集结|北峰通信亮相11届警博会，多场景助力警务智能化

“警”彩集结|北峰通信亮相11届警博会，多场景助力警务智能化

2023年5月11日-14日&#xff0c;第十一届中国国际警用装备博览会(警博会)在北京首钢会展中心隆重召开。“警博会”作为中国乃至亚太地区最具影响力、最权威的警用装备盛会&#xff0c;代表了中国警用装备行业的最高水平。北峰通信作为服务公共安全实战30余年的企业&#xff0c;…
阅读更多...
软考A计划-真题-分类精讲汇总-第十二章(法律法规与标准化)

软考A计划-真题-分类精讲汇总-第十二章(法律法规与标准化)

点击跳转专栏>Unity3D特效百例点击跳转专栏>案例项目实战源码点击跳转专栏>游戏脚本-辅助自动化点击跳转专栏>Android控件全解手册点击跳转专栏>Scratch编程案例 &#x1f449;关于作者 专注于Android/Unity和各种游戏开发技巧&#xff0c;以及各种资源分享&am…
阅读更多...
Web渗透 不断更新

Web渗透 不断更新

Web渗透 SQL注入一般注入步骤 文件上传漏洞过滤绕过空格绕过 针对Linux特定字符过滤绕过 针对Linux(例如&#xff1a;cat) 序列号unserialize SQL注入 一般注入步骤 注入点 --> 查询注入字段数 --> 查询注入回显位 --> 查询当前数据库信息 --> 查询数据库表 --&g…
阅读更多...
MySQL基础（三十四）锁

MySQL基础（三十四）锁

1. 概述 在数据库中&#xff0c;除传统的计算资源&#xff08;如CPU、RAM、I/O等&#xff09;的争用以外&#xff0c;数据也是一种供许多用户共享的 资源。为保证数据的一致性&#xff0c;需要对 并发操作进行控制&#xff0c;因此产生了 锁 。同时 锁机制 也为实现MySQL 的各…
阅读更多...
HIT数据结构lab2-树型结构的建立与遍历

HIT数据结构lab2-树型结构的建立与遍历

title: 数据结构lab2-树型结构的建立与遍历 date: 2023-05-16 11:42:26 tags: 数据结构与算法 哈尔滨工业大学计算机科学与技术学院 实验报告 课程名称&#xff1a;数据结构与算法 课程类型&#xff1a;必修 实验项目&#xff1a;树型结构的建立与遍历 实验题目&#xff1…
阅读更多...
【目标检测】模型信息解析/YOLOv5检测结果中文显示

【目标检测】模型信息解析/YOLOv5检测结果中文显示

前言 之前写过一篇博文【目标检测】YOLOv5&#xff1a;标签中文显示/自定义颜色&#xff0c;主要从显示端解决目标中文显示的问题。 本文着重从模型角度&#xff0c;从模型端解决目标中文显示问题。 模型信息解析 正常情况下&#xff0c;可以直接加载模型打印信息&#xff0…
阅读更多...
GPT专业应用：英语作文修改与解释

GPT专业应用：英语作文修改与解释

正文共 868 字&#xff0c;阅读大约需要 3 分钟 英语学习者/老师必备技巧&#xff0c;您将在3分钟后获得以下超能力&#xff1a; 快速修改英语作文 Beezy评级 &#xff1a;B级 *经过简单的寻找&#xff0c; 大部分人能立刻掌握。主要节省时间。 推荐人 | Kim 编辑者 | Linda …
阅读更多...
字节外包做了5年软件测试，12月无情被辞，想给划水的兄弟提个醒

字节外包做了5年软件测试，12月无情被辞，想给划水的兄弟提个醒

前言 先简单交代一下背景吧&#xff0c;某不知名 985 的本硕&#xff0c;17 年毕业加入字节&#xff0c;以“人员优化”的名义无情被裁员&#xff0c;之后跳槽到了有赞&#xff0c;一直从事软件测试的工作。之前没有实习经历&#xff0c;算是5年的工作经验吧。 这5年之间完成…
阅读更多...
第45讲：Python集合对象生成式的概念以及应用案例

第45讲：Python集合对象生成式的概念以及应用案例

文章目录 1.什么是集合生成式3.使用集合生成式创建集合3.在集合生成式中使用if语句4.在集合生成式中使用嵌套for循环语句 集合的生成式和集合的非常类似&#xff0c;只是符号不同而已&#xff0c;集合的语法格式如下&#xff0c;可以看到只是和集合的符号不同&#xff1a; {集…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023