数据结构与算法(C语言版)P3.1---链表(无头单向非循环链表)

已于 2023-09-16 14:10:27 修改
阅读量158 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： c语言 链表 开发语言 算法 数据结构
于 2023-09-16 11:42:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57776598/article/details/132912204
版权

1、链表的概念及结构

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

在这里插入图片描述

注意：

​ 1、从上图可看出：链式结构在逻辑上是连续的，但是在物理上不一定连续。

​ 2、现实中的结点一般都是从堆上申请出来的。

​ 3、从堆上申请空间，是按照一定策略来分配的，再次申请的空间可能连续，不可能不连续。

链表中的结点也是动态内存分配空间，按需分配。

假设在32位系统上，结点中值域为int类型，则一个结点的大小位8字节，则可能有如下链表：

在这里插入图片描述

链表结构中的结点由两部分组成：

  • 数据域：存储元素数值数据。
  • 指针域：存储直接后继节点的存储位置。

2、链表的分类

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

在这里插入图片描述

结点只有一个指针域的链表，称为单链表或线性表。

结点有两个指针域的链表，称为双链表。

首尾相接的链表称为循环链表。

头指针、头结点和首元结点：

在这里插入图片描述

头指针：是指向链表中第一个结点的指针。

首元结点：是指链表中存储第一个数据元素a1的结点。

头结点（哨兵位）：是在链表的首元结点之前附设的一个结点，此节点不存储数据，只记录首元结点的地址。

讨论一：在链表中设置头结点有什么好处？

1、便于首元节点的处理：

​ 首元结点的地址保存在头结点的指针域中，所以在链表的第一个位置上的操作和其它位置一致，无须进行 特殊处理。

2、便于空表和非空表的统一处理：

​ 无论链表是否为空，头指针都是指向头结点的非空指针，因此空表和非空表的处理也就统一了。

讨论二：头结点的数据域内装的是什么呢？

​ 头结点的数据域可以为空，也可以存放线性表长度等附加信息，但此结点不能计入链表长度值。

1、单向或者双向

在这里插入图片描述

2、带头或者不带头

在这里插入图片描述

3、循环和非循环

在这里插入图片描述

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

​ 1、无头单向非循环链表

​ 在这里插入图片描述

​ 2、带头双向循环链表

​

1、无头单向非循环链表：结构简单，一般不会单独用来__存放数据__，实际中更多是作为__其它数据结构的子结构__，如：哈希桶，图的邻接表等等。另外这种结构在笔试中出现很多。

2、带头双向循环链表：结构复杂，一般用在单独存储数据。实际中使用的链表结构，都是带头双向链表，另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

在这里插入图片描述
所以下面我们就实现以上两个最常用的链表。

3、无头单向非循环链表的实现

链表主要有以下几个接口功能：

  • 打印（SListPrint）
  • 销毁链表（SListDestory）
  • 扩容（BuyListNode）
  • 头插（SListPushFront）
  • 头删（SListPopFront）
  • 尾插（SListPushBack）
  • 尾删（SListPopBack）
  • 查找元素（SListFind）
  • 在pos位置之前插入（SListInsert）
  • 在pos位置之后去插入（SListErase）
  • 删除pos当前位置的数据（SeqListErase）
  • 删除pos位置之后的一个结点（SListEraseAfter)

和顺序表不同的是，无头单向非循环链表是不用初始化的。所以没有初始化接口。我们只需要在main函数中申请一个结点地址即可。如下：

int main()
{
	SLTNode* plist = NULL;
	return 0;
}

3.1、定义结构体

#pragma once;

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

typedef int SLDataType;

typedef struct SListNode
{
	SLDataType data;
	struct SListNode* Next;
}SLTNode;

data变量用于存储数据，叫做数据域。
Next指针变量用于存储下一个结点的地址，叫做指针域。

3.2、扩容

链表的好处之一就是存储一个数据就申请一块空间，所以在链表中进行任意擦汗如操作时，都需要先申请内存空间。

SLTNode* BuyListNode(SLDataType x)
{
	//创建新节点（就是需要尾插的那个结点）
	//注意这个newnode指针，它就是新节点的地址，后面将尾结点和新节点关联的时候，就需要用到此地址。
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));

	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->Next = NULL;
	return newnode;
}

3.3、头插

void SListPushFront(SLTNode** pphead, SLDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	newnode->Next = *pphead;
	*pphead = newnode;
}

3.4、打印

这里打印只需要传一级指针即可。只需打印输出，无需其它操作，所以传一级指针即可。

void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->Next;
	}
	printf("\n");
}

3.5、销毁

销毁链表的错误做法，不能直接操作：free(*pphead);
如果这样，只释放了头结点的地址，后面的结点的地址，都会找不到且无法释放。所以会造成内存泄漏。

正确的操作：一个结点一个结点的释放，并且在释放一个结点之前先把此结点的地址先保存来下来，以防找不到。

void SListDestroy(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->Next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

3.6、头删

头删的核心思想：先保存第二个结点的地址，然后释放头结点，最后再将头指针和第二个结点的地址链接起来。

void SListPopFront(SLTNode** pphead)
{
	assert(*pphead != NULL);
	
	//保存第二个结点
	SLTNode* next = (*pphead)->Next;
	//释放第一个结点
	free(*pphead);
	//重新链接结点
	*pphead = next;
}

3.7、尾插

尾插的核心思想：找到最后一个结点，然后和扩容的newnode新节点进行链接。

需要注意的是：由于我们实现的是无头链表，所以在进行结点的插入以及删除时，需要考虑，空链表，只有一个结点的特殊情况。

void SListPushBack(SLTNode** pphead, SLDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
	//首先需要找到链表中的尾结点,尾结点有个特征：它的Next为NULL。
		SLTNode* tail = *pphead;
		while (tail->Next)
		{
			tail = tail->Next;
		}
		//关联尾节点和新节点
		tail->Next = newnode;
	}
}

3.8、尾删

尾删的核心思想：同时找到最后一个结点和倒数第二个结点。然后释放最后一个结点，并且将倒数第二个结点的Next指为NULL。

这里也需要考虑3种情况：没有结点，只有一个结点，有多个结点。

void SListPopBack(SLTNode** pphead)
{
	//先处理没有结点的情况，直接断言即可。
	assert(*pphead != NULL);

	//其次处理只有一个结点的情况
	if ((*pphead)->Next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//最后考虑的就是有多个结点的情况
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;

		while (tail->Next)
		{
			prev = tail;
			tail = tail->Next;
		}
		free(tail);
		tail = NULL;
		prev->Next = NULL;
	}
}

3.9、查询指定元素，并返回结点地址pos

SLTNode* SListFind(SLTNode* phead, SLDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (x == cur->data)
		{
			return cur;
		}
		else
		{
			cur = cur->Next;
		}
	}
	return NULL;
}

3.10、在pos位置之前插入

核心思想：找到pos结点前面的结点，然后依次链接起来即可。

特殊情况：需要考虑只有一个结点和多个结点的情况

void SListInsert(SLTNode** pphead, SLTNode* pos, SLDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	//这个用于只有一个结点的情况
	if (*pphead == pos)
	{
		*pphead = newnode;
		newnode->Next = pos;
	}
	//这个用于多个结点前插入数据
	else
	{
		SLTNode* posPrev = *pphead;
		//找到pos的前一个位置
		while (posPrev->Next != pos)
		{
			posPrev = posPrev->Next;
		}
		//链接
		posPrev->Next = newnode;
		newnode->Next = pos;
	}
}

在pos之前插入的时间复杂度分析。这里分三种情况：

  • 直接是头插，那时间复杂度是O(1)
  • 需要插入的数据在中间
  • 需要插入的数据在最后一个结点前，所以是O(N)。

所以取悲观预期，综合来说时间复杂度是O(N)。

3.11、在pos位置之后插入

在pos位置之后插入比在pos位置之前插入简单。就直接依次链接即可。

void SListInsertAfter(SLTNode** pphead, SLTNode* pos,SLDataType x)
{
	SLTNode* newnode = BuyListNode(x);

	SLTNode* posNext = pos->Next;
	pos->Next = newnode;
	newnode->Next = posNext;
}

在pos之后插入的时间复杂度分析：
在pos位置之后插入，由于确定好了插入的位置，可以直接插入。所以时间复杂度为O(1)。

相比在pos位置之前插入，结点，更推荐使用pos位置之后插入结点。

3.12、删除pos当前位置结点

核心思想：找到pos前一个结点，将pos前一个结点和pos后一个结点链接，然后释放pos。

考虑情况：

  • 只有一个结点
  • 有多个结点
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	//删除头结点
	if (*pphead == pos)
	{
		*pphead = pos->Next;
		free(pos);
	}
	//删除非头结点的其它结点。
	else
	{
		SLTNode* posPrev = *pphead;
		while (posPrev->Next != pos)
		{
			posPrev = posPrev->Next;
		}
		posPrev->Next = pos->Next;
		free(pos);
	}
}

删除pos位置当前的时间复杂度：O(N)。

3.13、删除pos位置之后的结点

很简单，直接链接。

void SListEraseAfter(SLTNode* pos)
{
	assert(pos->Next);
	SLTNode* next = pos->Next;
	pos->Next = next->Next;
	free(next);
}

在pos位置之后的时间复杂度：O(1)。

4、全代码展示

这里使用三个文件：

  • seqlist.h：用于结构体、各种函数接口的声明
  • seqlist.c：用于各种函数接口的定义。
  • test.c：用于创建链表，实现链表。

4.1、seqlist.h

#pragma once;

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

typedef int SLDataType;

typedef struct SListNode
{
	SLDataType data;
	struct SListNode* Next;
}SLTNode;

//扩容
SLTNode* BuyListNode(SLDataType x);

//头插
void SListPushFront(SLTNode** pphead, SLDataType x);

//打印
void SListPrint(SLTNode* phead);

//销毁
void SListDestroy(SLTNode** pphead);

//头删
void SListPopFront(SLTNode** pphead);

//尾插
void SListPushBack(SLTNode** pphead, SLDataType x);

//尾删
void SListPopBack(SLTNode** pphead);

//查询指定元素，返回结点地址
SLTNode* SListFind(SLTNode* phead,SLDataType x);

//在pos位置之前插入结点
void SListInsert(SLTNode** phead, SLTNode* pos, SLDataType x);

//在pos位置之后插入结点
void SListInsertAfter(SLTNode** pphead, SLTNode* pos,SLDataType x);

//删除当前pos位置结点
void SListErase(SLTNode** pphead, SLTNode* pos);

//删除pos位置之后的结点
void SListEraseAfter(SLTNode* pos);

4.2、seqlist.c

#include "list.h"

//扩容
SLTNode* BuyListNode(SLDataType x)
{
	//创建新节点（就是需要尾插的那个结点）
	//注意这个newnode指针，它就是新节点的地址，后面将尾结点和新节点关联的时候，就需要用到此地址。
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));

	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->Next = NULL;
	return newnode;
}

//头插
void SListPushFront(SLTNode** pphead, SLDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	newnode->Next = *pphead;
	*pphead = newnode;
}

//打印
void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->Next;
	}
	printf("\n");
}

//销毁
void SListDestroy(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->Next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

//头删
void SListPopFront(SLTNode** pphead)
{
	assert(*pphead != NULL);
	
	//保存第二个结点
	SLTNode* next = (*pphead)->Next;
	//释放第一个结点
	free(*pphead);
	//重新链接结点
	*pphead = next;
}

//尾插
void SListPushBack(SLTNode** pphead, SLDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->Next)
		{
			tail = tail->Next;
		}
		tail->Next = newnode;
	}
}

//尾删
void SListPopBack(SLTNode** pphead)
{
	if ((*pphead)->Next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;

		while (tail->Next)
		{
			prev = tail;
			tail = tail->Next;
		}
		free(tail);
		tail = NULL;
		prev->Next = NULL;
	}
}

//查询指定元素，返回结点地址
SLTNode* SListFind(SLTNode* phead, SLDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (x == cur->data)
		{
			return cur;
		}
		else
		{
			cur = cur->Next;
		}
	}
	return NULL;
}

//在pos位置之前插入结点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	
	if (*pphead == pos)
	{
		*pphead = newnode;
		newnode->Next = pos;
	}
	else
	{
		SLTNode* posPrev = *pphead;
		while (posPrev->Next != pos)
		{
			posPrev = posPrev->Next;
		}
		posPrev->Next = newnode;
		newnode->Next = pos;
	}
}

//在pos位置之后插入结点
void SListInsertAfter(SLTNode** pphead, SLTNode* pos,SLDataType x)
{
	SLTNode* newnode = BuyListNode(x);

	SLTNode* posNext = pos->Next;
	pos->Next = newnode;
	newnode->Next = posNext;
}

//删除当前pos位置结点
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	if (*pphead == pos)
	{
		*pphead = pos->Next;
		free(pos);
	}
	else
	{
		SLTNode* posPrev = *pphead;
		while (posPrev->Next != pos)
		{
			posPrev = posPrev->Next;
		}
		posPrev->Next = pos->Next;
		free(pos);
	}
}

//删除pos位置之后的结点
void SListEraseAfter(SLTNode* pos)
{
	assert(pos->Next);
	SLTNode* next = pos->Next;
	pos->Next = next->Next;
	free(next);
}

4.3、test.c

#include "list.h"

void TestList1()
{
	SLTNode* plist = NULL;

	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListPushFront(&plist, 5);
	SListPushFront(&plist, 6);

	SLTNode* pos = SListFind(plist, 3);
	SListEraseAfter(pos);

	SListPrint(plist);

	SListDestroy(&plist);
}

int main()
{
	TestList1();
	return 0;
}
让我三行代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言数据结构(3)----无头单向非循环链表
m0_73096566的博客
02-27 814
C语言数据结构(3)----无头单向非循环链表
数据结构与算法 -- -- -- 队列 与 链表（约瑟夫问题）
qq_58293159的博客
03-19 462
队列 与链表的介绍 实现 与 思路分析 + 代码 【单链表 ，双链表 ，环形链表】的介绍
【尚硅谷】Java数据结构与算法笔记03 - 链表
热门推荐
知不足而奋进，望远山而前行
12-07 1万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
Python数据结构与算法篇（十一）-- 链表的应用与常见题型
CarpeDiem
03-14 1767
本篇信息量巨大，首先对比链表和数组，接着解决单链表的反转、删除某一节点、插入数据、查找中间节点、求倒数第k个结点、对称链表、单链表是否有环、两个链表是否相交，最后用LeetCode上的真题来实战删除链表结点、反转链表、合并、排序、环形链表常用技巧。
数据结构（四） -- C语言版 -- 线性表的链式存储 - 循环链表
青椒*^_^*凤爪爪的博客
03-13 9582
本文中没有涉及到很多的相关理论知识，也没有做深入的了解，所以，您如果是想要系统的学习、想要多学习关于理论的知识等，那么本文可能并不合适您。 本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。 设计的代码并非全部公开，部分无关紧要代码并没有贴出来。 如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。 由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。 嘻嘻。。。。 。。。。。。。。收！
Python算法与数据结构（三）------ 链表
weixin_42032917的博客
12-12 238
python链表目录一. 链表作用和定义1.1作用1.2定义二. 单向链表2.1定义：2.2 单链表的操作2.3单链表节点的实现2.4 单链表的头部添加元素与尾部添加元素2.5 单链表在指定位置添加元素2.6 删除节点2.7 链表与顺序表的对比三. 单向循环链表3.1 定义3.2 操作3.3 操作实现四. 双向链表4.1定义4.2 操作4.3 链表节点的实现4.4 操作实现 目录 一. 链表作用和...
02-数据结构与算法-单向链表
Kevin-Ding的博客
02-24 343
数据结构与算法中单向链表的介绍，及常见的关于单向链表的面试题
数据结构与算法【Java】02---链表
鹤鸣呦呦、、的博客
08-11 101
链表是有序的列表，但是它在内存中是存储如下Josephu(约瑟夫、约瑟夫环) 问题Josephu 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1
数据结构与算法 python--第三节 链表之单向循环链表
MissingDi的博客
03-04 264
文章目录3 链表3.1 单向链表3.2 双向链表3.3 单向循环链表遍历元素travel()链表长度length() 3 链表 3.1 单向链表 见前博客：数据结构与算法 python–第三节 链表之单向链表 3.2 双向链表 见前博客：数据结构与算法 python–第三节 链表之双向链表 3.3 单向循环链表 单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向...
数据结构与算法 python–第三节 链表之单向链表
01-20
文章目录3 链表3.1 单向链表单链表的操作单链表是否为空、长度、遍历操作头部添加元素 add()尾部添加元素append()指定位置添加元素insert(pos,item)删除节点remove(item)查找节点是否存在search（item）完整代码链表...
【Java演示】什么是链表？数据结构（三）
01-20
目录链表：随机存储，顺序访问（读取）前言一、单向链表什么叫随机存储呢？链表的基本操作1. 查找节点2. 更新节点3. 插入节点3.1. 尾部插入3.2. 头部插入3.3. 中间插入4. 删除元素4.1. 尾部删除4.1. 头部删除4.1. ...
python数据结构与算法，python入门、竞赛必备
04-27
3.1. 单向链表 3.2. 单项循环链表 3.3. 双向链表 4. 栈 4.1. 栈结构实现 5. 队列 5.1. 队列的实现 5.2. 双端队列 6. 排序与搜索 6.1. 冒泡排序 6.2. 选择排序 6.3. 插入排序 6.4. 快速排序 6.5. 希尔排序 6.6. 归并...
cpp-在C中的算法和数据结构
08-16
链表分为单向链表、双向链表和循环链表，每种都有其特定的应用场景。 2.2 栈与队列：栈遵循“后进先出”（LIFO）原则，常见操作是push（入栈）和pop（出栈）。队列遵循“先进先出”（FIFO）原则，常用操作是enqueue...
[C/C++入门][循环]14、计算2的幂(2的n次方）
qq_14840819的专栏
07-15 914
计算2的幂（即2的n次方）非常经典。你懂几种方法呢？很多人只会一种，我们来分析一下。
[C/C++入门][ifelse]15、判断奇偶数
qq_14840819的专栏
07-16 342
在数学中，判断一个整数是否为奇数或偶数的依据是基于数的模运算。对于任意整数 n，当 n除以2的余数等于0 时，n 是偶数；当 余数为1 时，n 是奇数。计算机中% 表示模运算，即求余数。尝试运行以下这段代码，看看它如何工作。如果有疑问，随时留在评论区，我们一起讨论吧。
PD协议芯片ECP5701+充电管理芯片+升压芯片搭配应用TYPE-C口充电及升压供电系统
IC_Aihui的博客
07-18 704
能芯科技ECP5701是一颗PD取电芯片，支持PD和QC取电，兼容USB PD3.0规范，并向下支持USB PD2.0，支持QC3.0和QC2.0，支持PD取电5、9、12、15、20V电压，QC取电9V和12V，芯片采用SOP8封装，外围简单。然而，TYPE-C接口，全称USB Type-C，迅速取代了传统的USB接口，不仅如此，TYPE-C接口的普及和PD（Power Delivery）取电协议芯片的出现，这一切便有了转机，这在快节奏的现代生活中，为我们的设备充电带来了极大的便利。
TYPE-C接口PD取电快充协议芯片ECP5701：支持PD 2.0和PD 3.0(5V,9V,12V,15V,20V)
最新发布
IC_Aihui的博客
07-18 434
PD取电快充协议芯片接收到请求信号后，会根据电池的容量、充电器的功率以及当前电池的状态等因素，计算出合适的电压和电流，然后向充电器发送反馈信号。总的来说，TYPE-C接口和PD取电快充协议的结合，是现代电子设备充电技术的一大进步，它们的普及和应用，无疑让我们的生活更加便捷，更加智能。比如可以配置适配器输出需要的电压，给。而TYPE-C接口作为新一代的USB接口，具有正反插、传输速度快、充电体验好等优点，已经成为了快充技术的主要接口形式。◇ 可自动匹配 PD 输出 5V，9V，12V，15V，20V电压。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 游乐园门票 (200分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
07-14 616
- 一日票: 仅限当日有效 - 三日票: 从购买当日起,连续3天内有效 - 周票: 从购买当日起,连续7天内有效 - 月票: 从购买当日起,连续30天内有效 现在给定每种门票的价格,以及LYA计划在未来一年内的游玩日期,请帮助LYA计算出她需要支付的最低门票费用。
C语言解析数据结构与算法-金典教材解析
"《数据结构与算法-C语言描述-金典算法教材》是Mark Allen Weiss的经典著作，专注于数据结构和算法分析，采用C语言作为实现工具。本书在全球500多所大学被用作教材，深入浅出地介绍了抽象数据类型和算法效率评估。" ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

让我三行代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值