C语言实现 -- 单链表

news2024/11/13 15:33:38

C语言实现 -- 单链表

  • 1.顺序表经典算法
    • 1.1 移除元素
    • 1.2 合并两个有序数组
  • 2.顺序表的问题及思考
  • 3.链表
    • 3.1 链表的概念及结构
    • 3.2 单链表的实现
  • 4.链表的分类

讲链表之前，我们先看两个顺序表经典算法。

1.顺序表经典算法

1.1 移除元素

经典算法OJ题1：移除元素
在这里插入图片描述

思路：双指针法

不是真的定义指针，而是两个变量。
执行步骤：
定义两个变量：src 和 dst
如果src指向的值等于val，src++
如果src指向的值不等于val，arr[dst] = arr[src],src++,dst++

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

代码实现：
在这里插入图片描述

1.2 合并两个有序数组

经典算法OJ题2：合并两个有序数组
在这里插入图片描述

思路：
从两个数组的最后一个有效数据开始从后往前比较，找大，谁大就从num1数组的最后一个位置从后往前放。
代码如下：
在这里插入图片描述

2.顺序表的问题及思考

问题：
1.中间/头部的插入删除，时间复杂度为O(N)

  • 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  • 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
    思考：如何解决以上问题呢？下面给出了链表的结构来看看。
    在这里插入图片描述

3.链表

3.1 链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
逻辑结构是线性的，物理结构不是线性的。
在这里插入图片描述

  • 链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉/加上，不会影响其他车厢，每节车厢都是独立存在的。
  • 车厢是独立存在的，且每节车厢都有车门。想象一下这样的场景，假设每节车厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带一把钥匙的情况下如何从车头走到车尾？

最简单的做法：每节车厢里都放一把下一节车厢的钥匙。
在链表里，每节“车厢”是什么样的呢？
在这里插入图片描述
1.与顺序表不同的是，链表里的每节"车厢"都是独立申请下来的空间，我们称之为“结点/节点”，链表是由一个一个的节点(结点)组成的。
2.节点的组成主要有两个部分：data:当前节点要保存的数据和*next:保存下一个节点的地址（指针变量）（它指向的是一个结构体，所以是结构体指针，那这个结构体就是我们链表中的结点）。
3.图中指针变量plist保存的是第⼀个节点的地址，我们称plist此时“指向”第一个节点，如果我们希望plist“指向”第二个节点时，只需要修改plist保存的内容0x0012FFA0。
4.为什么还需要指针变量来保存下一个节点的位置？
链表中每个节点都是独立申请的（即需要插入数据时才去申请⼀块节点的空间），
我们需要通过指针变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。
结合前面学到的结构体知识，我们可以给出每个节点对应的结构体代码：
假设当前保存的节点为整型：
在这里插入图片描述
当我们想要保存⼀个整型数据时，实际是向操作系统申请了一块内存，这个内存不仅要保存整型数据，也需要保存下一个节点的地址（当下一个节点为空时保存的地址为空）。
当我们想要从第一个节点走到最后一个节点时，只需要在前一个节点拿上下一个节点的地址（下一个节点的钥匙）就可以了。
给定的链表结构中，如何实现节点从头到尾的打印？
在这里插入图片描述
思考：当我们想保存的数据类型为字符型、浮点型或者其他自定义的类型时，该如何修改？
typedef int SLTDataType; 直接把int 换成char ,float 等等
补充说明：
1、链式机构在逻辑上是连续的，在物理结构上不⼀定连续
2、节点⼀般是从堆上申请的
3、从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续。

3.2 单链表的实现

1.首先在头文件中定义一个结构体
在这里插入图片描述
其次要明白
在这里插入图片描述

2. 链表的打印
在这里插入图片描述
3.申请新节点
在这里插入图片描述

4. 尾插
在这里插入图片描述
首先我们要知道一级指针和二级指针的关系
指针变量plist 存放的是第一个结点node的地址，所以plist指向第一个结点的指针。
二级指针变量pplist存放的是一级指针变量plist的地址,所以pplist 指向一级指针的变量。
在这里插入图片描述

代码：
在这里插入图片描述
5.头插
在这里插入图片描述
代码：
在这里插入图片描述
6.尾删
在这里插入图片描述
代码：

在这里插入图片描述
7.头删
在这里插入图片描述
代码：

在这里插入图片描述
8.查找
在这里插入图片描述
9.在指定位置之前插入数据
在这里插入图片描述
代码：
在这里插入图片描述
10.在指定位置之后插入数据
在这里插入图片描述
代码：
在这里插入图片描述
11.删除pos节点
在这里插入图片描述
代码：
在这里插入图片描述
12.删除pos之后的节点
在这里插入图片描述
代码：
在这里插入图片描述
13.销毁链表
在这里插入图片描述
代码：
在这里插入图片描述

下面是完整代码：
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;

//typedef struct SListNode SLTNode;

void SLTPrint(SLTNode* phead);

//链表的头插、尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
void SLTPushFront(SLTNode** pphead, SLTDataType x);

//链表的头删、尾删
void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

//查找
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x);

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);

//销毁链表
void SListDesTroy(SLTNode** pphead);

SList.c

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

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

	return newnode;
}

void SLTPushBack(SLTNode** pphead, SLTDataType x) {
	assert(pphead);

	SLTNode* newnode = SLTBuyNode(x);

	//链表为空，新节点作为phead
	if (*pphead == NULL) {
		*pphead = newnode;
		return;
	}
	//链表不为空，找尾节点
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//ptail就是尾节点
	ptail->next = newnode;
}
void SLTPushFront(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);

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

	//链表不为空
	//链表只有一个节点，有多个节点
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;
	while (ptail->next)
	{
		prev = ptail;
		ptail = ptail->next;
	}
	
	prev->next = NULL;
	//销毁尾结点
	free(ptail);
	ptail = NULL;
}
void SLTPopFront(SLTNode** pphead) {
	assert(pphead);
	//链表不能为空
	assert(*pphead);

	//让第二个节点成为新的头
	//把旧的头结点释放掉
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}
//查找
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x) {
	assert(pphead);

	//遍历链表
	SLTNode* pcur = *pphead;
	while (pcur) //等价于pcur != NULL
	{
		if (pcur->data == x) {
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}
//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
	assert(pphead);
	assert(pos);
	//要加上链表不能为空
	assert(*pphead);

	SLTNode* newnode = SLTBuyNode(x);
	//pos刚好是头结点
	if (pos == *pphead) {
		//头插
		SLTPushFront(pphead, x);
		return;
	}

	//pos不是头结点的情况
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//prev -> newnode -> pos
	prev->next = newnode;
	newnode->next = pos;
}
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x) {
	assert(pos);

	SLTNode* newnode = SLTBuyNode(x);

	//pos newnode pos->next
	newnode->next = pos->next;
	pos->next = newnode;
}
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos) {
	assert(pphead);
	assert(*pphead);
	assert(pos);

	//pos刚好是头结点，没有前驱节点，执行头删
	if (*pphead == pos) {
		//头删
		SLTPopFront(pphead);
		return;
	}

	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//prev pos pos->next
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos) {
	assert(pos);
	//pos->next不能为空
	assert(pos->next);

	//pos  pos->next  pos->next->next
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}
//销毁链表
void SListDesTroy(SLTNode** pphead) {
	assert(pphead);
	assert(*pphead);

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

test.c

#include"SList.h"

//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;
//
//	SLTNode* plist = node1;
//	SLTPrint(plist);
//}
void SlistTest02() {
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist); //1->2->3->4->NULL

	//SLTPushFront(&plist, 5);
	//SLTPrint(plist);          //5->1->2->3->4->NULL
	//SLTPushFront(&plist, 6);
	//SLTPrint(plist);         //6->5->1->2->3->4->NULL
	//SLTPushFront(&plist, 7);
	//SLTPrint(plist);         //7-6->5->1->2->3->4->NULL

	SLTPopBack(&plist);
	SLTPrint(plist);//1->2->3->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);//1->2->3->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);//1->2->3->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);//1->2->3->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);//1->2->3->NULL
}

void SlistTest03() {
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist); //1->2->3->4->NULL

	SListDesTroy(&plist);
	头删
	//SLTPopFront(&plist);
	//SLTPrint(plist);    //2->3->4->NULL
	//SLTPopFront(&plist);
	//SLTPrint(plist);    //3->4->NULL
	//SLTPopFront(&plist);
	//SLTPrint(plist);    //4->NULL
	//SLTPopFront(&plist);
	//SLTPrint(plist);    //NULL
	//SLTPopFront(&plist);
	//SLTPrint(plist);    //assert
	//
	//SLTNode* FindRet = SLTFind(&plist, 3);
	//if (FindRet) {
	//	printf("找到了！\n");
	//}
	//else {
	//	printf("未找到！\n");
	//}
	//SLTInsert(&plist, FindRet, 100);
	//SLTInsertAfter(FindRet, 100);
	//
	//删除指定位置的节点
	//SLTErase(&plist, FindRet);
	//SLTPrint(plist); //1->2->3->NULL
}
int main() {
	//SlistTest01();
	//SlistTest02();
	SlistTest03();
	return 0;
}

4.链表的分类

链表的结构非常多样，以下情况组合起来就有8种（2x2x2）链表结构：
在这里插入图片描述
链表说明：
在这里插入图片描述
在这里插入图片描述
虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表。
1.无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2.带头双向循环链表：结构最复杂，⼀般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。
完

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

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

相关文章

在服务器上使用Dockerfile创建springboot项目的镜像和踩坑避雷

在服务器上使用Dockerfile创建springboot项目的镜像和踩坑避雷

1. 准备个文件夹 这是我的路径 /usr/local/springboot/docker-daka/docker_files2. 将jar包上传 springboot项目打包——maven的package 这是整个项目打包的模式&#xff0c;也可以分离依赖、配置和程序进行打包&#xff0c;详情看我这篇文章&#xff1a; springboot依赖 配…
阅读更多...
java基础 之 集合与栈的使用（四）

java基础 之 集合与栈的使用（四）

文章目录 Queue栈Stack队列和栈的区别小扩展自己写个简单的队列自己写个简单的栈使用栈来实现个队列使用队列来实现个栈写在最后 前文回顾&#xff1a; 戳这里 → java基础 之 集合与栈的使用&#xff08;一&#xff09; 戳这里 → java基础 之 集合与栈的使用&#xff08;二&a…
阅读更多...
windows中node版本的切换(nvm管理工具)，解决项目兼容问题 node版本管理、国内npm源镜像切换（保姆级教程，值得收藏）

windows中node版本的切换(nvm管理工具)，解决项目兼容问题 node版本管理、国内npm源镜像切换（保姆级教程，值得收藏）

前言 在工作中&#xff0c;我们可能同时在进行2个或者多个不同的项目开发&#xff0c;每个项目的需求不同&#xff0c;进而不同项目必须依赖不同版本的NodeJS运行环境&#xff0c;这种情况下&#xff0c;对于维护多个版本的node将会是一件非常麻烦的事情&#xff0c;nvm就是为…
阅读更多...
【Git】git 从入门到实战系列（二）—— git 介绍以及安装方法 (文末附带视频录制操作步骤)

【Git】git 从入门到实战系列（二）—— git 介绍以及安装方法 (文末附带视频录制操作步骤)

文章目录 一、前言二、git 是什么三、版本控制系统是什么四、本地 vs 集中式 vs 分布式本地版本控制系统集中式版本控制系统分布式版本控制系统 五、安装 git 一、前言 本系列上一篇文章【Git】git 从入门到实战系列&#xff08;一&#xff09;—— Git 的诞生&#xff0c;Lin…
阅读更多...
Linux系统编程 --- 基础IO

Linux系统编程 --- 基础IO

形成共识原理&#xff1a; 1、文件 内容 属性 2、文件分为打开的文件和没打开的文件 3、打开的文件&#xff1a;谁打开&#xff1f;进程&#xff01;--- 本质是研究进程和文件的关系&#xff01; 文件被打开&#xff0c;必须先被加载到内存&#xff01; 一个进程可以打开…
阅读更多...
PyTorch 训练自定义功能齐全的神经网络模型的详细教程

PyTorch 训练自定义功能齐全的神经网络模型的详细教程

在前面的文章中&#xff0c;老牛同学介绍了不少大语言模型的部署、推理和微调&#xff0c;也通过大模型演示了我们的日常的工作需求场景。我们通过大语言模型&#xff0c;实实在在的感受到了它强大的功能&#xff0c;同时也从中受益颇多。 今天&#xff0c;老牛同学想和大家一…
阅读更多...
【Android Studiio】default activity 原生安卓和uniapp默认启动分析

【Android Studiio】default activity 原生安卓和uniapp默认启动分析

文章目录 思路&#xff1a; 一、原生安卓二、uniapp 探究方向&#xff1a;找到Default Activity 思路&#xff1a; 在Android开发中&#xff0c;"default activity"这个概念通常指的是应用启动时默认会加载和显示的那个Activity。AndroidManifest.xml文件是Android…
阅读更多...
基于Selenium实现操作网页及操作windows桌面应用

基于Selenium实现操作网页及操作windows桌面应用

Selenium操作Web页面 Why? 通常情况下&#xff0c;网络安全相关领域&#xff0c;更多是偏重于协议和通信。但是&#xff0c;如果协议通信过程被加密或者无法了解其协议构成&#xff0c;是无法直接通过协议进行处理。此时&#xff0c;可以考虑模拟UI操作&#xff0c;进而实现相…
阅读更多...
声音和数据之间的调制解调 —— 电报机和电传打字机如何影响计算机的演变

声音和数据之间的调制解调 —— 电报机和电传打字机如何影响计算机的演变

注&#xff1a;机翻&#xff0c;未校对。 The Squeal of Data The through line between the telegraph and the computer is more direct than you might realize. Its influence can be seen in common technologies, like the modem. 电报和计算机之间的直通线比你想象的要…
阅读更多...
基于IOT架构的数据采集监控平台！

基于IOT架构的数据采集监控平台！

LP-SCADA数据采集监控平台是蓝鹏测控推出的一款聚焦于工业领域的自动化数据采集监控系统&#xff0c; 助力数字工厂建设的统一监控平台。 为企业提供从下到上的完整的生产信息采集与集成服务&#xff0c;从而为企业综合自动化、工厂数字化及完整的"管控一体化”的解决方案…
阅读更多...
LockSupport详解

LockSupport详解

文章目录 理解可重入锁LockSupport线程等待唤醒机制&#xff08;wait/notify&#xff09; waitNotify限制awaitSignal限制LockSupport重点说明 理解可重入锁 可重入锁的种类&#xff1a; 隐式锁&#xff08;即synchronized关键字使用的锁&#xff09;默认是可重入锁。 同步代…
阅读更多...
站在临床数据科学的角度，药物试验归根结底是这两大假设

站在临床数据科学的角度，药物试验归根结底是这两大假设

在临床数据科学的领域中&#xff0c;药物试验的设计和实施是评估药物效果及其安全性的关键环节。药物试验的基础无外乎两大核心假设&#xff1a;有效性与安全性。这两个假设不仅是药物试验的起点&#xff0c;也是整个研究过程中的重要指导原则。 药物试验的核心主旨在于对待测试…
阅读更多...
Python高性能计算：进程、线程、协程、并发、并行、同步、异步

Python高性能计算：进程、线程、协程、并发、并行、同步、异步

这里写目录标题 进程、线程、协程并发、并行同步、异步I/O密集型任务、CPU密集型任务 进程、线程、协程 进程、线程和协程是计算机程序执行的三种不同方式&#xff0c;它们在资源管理、执行模型和调度机制上有显著的区别。以下是对它们的详细解释和比较&#xff1a; 进程&…
阅读更多...
一款有趣的工具，锁定鼠标键盘，绿色免安装

一款有趣的工具，锁定鼠标键盘，绿色免安装

这是一款完全免费的程序&#xff0c;可以实现在不锁定屏幕的情况下锁定鼠标键盘&#xff0c;让鼠标键盘无法操作。比较适合防止误碰鼠标键盘&#xff0c;以及离开电脑时不希望别人操作自己的电脑。 ★★★★★锁定鼠标键盘工具&#xff1a;https://pan.quark.cn/s/e5c518a2165…
阅读更多...
路由配置修改（五）

路由配置修改（五）

一、默认约定式路由 1、umi 会根据 pages 目录自动生成路由配置。 * name umi 的路由配置* description 只支持 path,component,routes,redirect,wrappers,name,icon 的配置* param path path 只支持两种占位符配置&#xff0c;第一种是动态参数 :id 的形式&#xff0c;第二种…
阅读更多...
win11 intel新显卡控制面板无自定义分辨率选项解决

win11 intel新显卡控制面板无自定义分辨率选项解决

问题 下图是现在的intel显卡控制面板&#xff0c;不知道为啥变得很傻瓜式了&#xff0c;连所有显卡控制面板都有的分辨率自定义也被干掉了。 解决方式 其实解决很简单&#xff0c;因为自定义分辨率对显卡玩游戏来说还是很常用的&#xff0c;intel在beta版又加回来了&#x…
阅读更多...
样式与特效（2）——新闻列表

样式与特效（2）——新闻列表

1.盒子模型的边距概念 ) Margin-top 上面 Margin-bottom 底部 Margin-right 右边 Margin-left 左边 Margin : 10px &#xff08;上下左右都是10px&#xff09; Margin &#xff1a;10px,20px (上下边距10px 左右20px) CSS里面最重要的属性之一 将页面理解成…
阅读更多...
C++ | Leetcode C++题解之第316题去除重复字母

C++ | Leetcode C++题解之第316题去除重复字母

题目&#xff1a; 题解&#xff1a; class Solution { public:string removeDuplicateLetters(string s) {vector<int> vis(26), num(26);for (char ch : s) {num[ch - a];}string stk;for (char ch : s) {if (!vis[ch - a]) {while (!stk.empty() && stk.back(…
阅读更多...
C#值类型和引用类型，类和结构体

C#值类型和引用类型，类和结构体

1、类class是引用类型&#xff0c;多个引用类型变量的值会互相影响。存储在堆&#xff08;heap&#xff09;上 2、结构体struct是值类型&#xff0c;多个值类型变量的值不会互相影响。存储在栈&#xff08;stack&#xff09;上 using System; using System.Collections.Generi…
阅读更多...
PTA题目|象限的判断（python）

PTA题目|象限的判断（python）

题目要求 输入一对坐标&#xff0c;输出它在直角坐标系中的象限。 输入格式: 输入坐标(x,y)&#xff0c;&#xff08;假设输入的x或y坐标值一定不会为0&#xff09;如&#xff1a;(3.5,-2)。 输出格式: 输出对应的象限&#xff0c;如&#xff1a;第四象限 输入样例: 在这…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023