与队列和栈相关的【OJ题】

news2024/11/17 17:40:00

32becbd905a5411d8b4827566ec69ec4.jpeg

✨✨✨专栏：数据结构     

          🧑‍🎓个人主页：SWsunlight

5d474da1272640588145b2285d51bdf6.gif

目录

 

 一、用队列实现栈：

1、2个队列的关联起来怎么由先进先出转变为先进后出：（核心）

 2、认识各个函数干嘛用的：

3、代码实现：

二、用栈实现队列：

1、题目:

2、思路：

 3、代码：

 三、设计循环队列:

1、题目：

 2、思路：

​编辑

3、代码：

 

 一、用队列实现栈：

内容如下：

654d26f0b2d54dc5863caf4f8aeb162f.png

 2个队列实现栈：：首先考虑的是  栈的规则：先进后出（后进先出）

                                                   队列的规则：先进先出

1、2个队列的关联起来怎么由先进先出转变为先进后出：（核心）

e59c31563ecf4ca6834c8ea8acaba4c1.png

 如上图，外围框架（虚构的，为了更好理解，让他具体化）就是我要实现的栈，而我要通过2个队列来实现栈，是不是是可以让小球先走上面的“通道”进去，全部小球（元素）进入上“通道”中，此时我排在通道最后的小球（元素）就是我要出栈的第一个数据。

如下图：2号球要第一个出栈，我们发现下“通道”是空的，那么我让2号球前面的球离开这个“通道”去到下面的通道，上通道就会剩下一个2号球，此时取2号球顺利的第一个走出去，就相当于栈的Top(将后进的元素取出)

547bcd2e0e4648da913d69dc63216c8b.png

1125b438160c4a6c9c9f4f606d909ecf.png 反复进行，就可以实现栈了，(队尾的元素能出栈，其他位置得绕着2个通道来回转（有点像明知她(他)不爱你，你还是要困死再这颗树），只有自己在成为队尾了（心灰意冷了），才会幡然醒悟（不能再一直停留再原地绕圈了，要向前看啦)

 2、认识各个函数干嘛用的：

可能只是对我而言 

我已经标好了，各个函数的功能：知道功能就好实现了

0d3dd4f7532b4948a150a2dc1a87a1ef.png

这个结构体的成员放2个队列即可：

 cae2ea53b23f43639dfcbb60bf923c8d.png

1c407e0554a442beab0e45d4de98d083.png

 结构体MyStack嵌套2个（队列）结构体（Queue）——>Queue的结构体在嵌套节点的结构体27709a53582f41e286b913b818744c67.png

如下：头节点后面还会链接更多的尾节点

1b07bf0d9a4940508dd3fa335af91bf9.png

 

3、代码实现：

将之前写队列的代码复制过来直接可以用了

typedef int QUDataType;
//节点
typedef struct QueueNode{
	
	QUDataType a;
	//一定要用指针，不然结构体的大小就无法确定了
	struct QueueNode *next;
}QuNode;
//再建立一个保存头和尾的结构体
typedef struct Queue {
	QuNode* head;
	QuNode* tail;
	int size;
}Queue;


//初始化头尾节点
void QuInto(Queue* q)
{
	//不能传空指针  即（q=NULL）
	assert(q);
	q->head = NULL;
	q->tail = NULL;
	q->size = 0;
}

//尾插(2种情况：1.头尾都为NUL  2.又数据入队列了)
void QuPush(Queue* q, QUDataType x)
{
	//申请空间
	QuNode* newnode = (QuNode*)malloc(sizeof(QuNode));
	//判空
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->a = x;
	newnode->next = NULL;//节点创建完成
	//判断尾的位置
	if (q->tail == NULL)
	{
		q->head = q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}

//头删(删除到尾以后，就不能再删了)
void QuPop(Queue* q)
{
	assert(q);
	//头的位置也不能为空
	assert(q->size!=0);
	//此时数据个数为1（也就是最后一个节点）
	if (q->head->next==NULL)
	{
		free(q->head);
		q->head = q->tail = NULL;
	}
	else//q->head != q->tail；
	{
		QuNode* next = q->head->next;
		free(q->head);
		q->head = next;
	}
	
	//数据个数也要减去
	q->size--;
	
}

//判空
bool QuEmpty(Queue* q)
{
	assert(q);
	//头尾都相等时到达同一个位置，此时就为真，其他的情况都为假；
	return q->size==0;
}

//取头数据
QUDataType QuFront(Queue* q)
{
	assert(q);
	assert(q->head);
	return q->head->a;
}

//取尾数据
QUDataType QuBack(Queue* q)
{
	assert(q);
	//队尾都为空了，已经没数据了
	assert(q->tail);
	return q->tail->a;
}
//数据个数
int QuSize(Queue* q)
{
	assert(q);
	return q->size;
}

//销毁空间(写进数据，想要一次性释放完就来用)
void QuDestroy(Queue* q)
{
	assert(q);
	QuNode* cur = q->head;
	while (cur)
	{
		QuNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->head = q->tail =NULL;
	q->size = 0;
}

//2个队列
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

//初始化
MyStack* myStackCreate() {
    MyStack*pts = (MyStack*)malloc(sizeof(MyStack));
    if(pts==NULL)
    {
        perror("malloc");
        //exit(1);
        return NULL;
    }
    QuInto(&pts->q1);
    QuInto(&pts->q2);
    return pts;  
}
//插入
void myStackPush(MyStack* obj, int x) {
    //判空插入,将数据插入不为空的队列
    if(!QuEmpty(&obj->q1))
    {
        QuPush(&obj->q2,x);
    }
    else
    {
        QuPush(&obj->q2,x);
    }
}
//删除并取出top元素
int myStackPop(MyStack* obj) {
    //假设法：no存不为空
    Queue* noEmpty = &obj->q1;
    Queue* empty = &obj->q2;
    if(!QuEmpty(empty))
    {
        noEmpty = &obj->q2;
        empty = &obj->q1;
    }
    //我们要让size-1个数据去到那条空通道
    while(QuSize(noEmpty)>1)
    {
        //头删，所以取头
        int x = QuFront(noEmpty);
        QuPop(noEmpty);
        //将其数据存到size-1个数据存入空道
        QuPush(empty,x);
    }
    //随便头还是尾取，因为此时这通道只有最后一个元素了
    int top =QuFront(noEmpty);
    QuPop(noEmpty);
    return top;
}
//直接取top元素
int myStackTop(MyStack* obj) {
    //不要删除，只是取元素，那么取不为空的通道的队尾元素（因为根据栈的原则：先出的是队尾元素）
    if(!QuEmpty(&obj->q1))
    {
        return QuBack(&obj->q1);
    }
    else
    {
        return QuBack(&obj->q2);
    }
}
//判空
bool myStackEmpty(MyStack* obj) {
    //2个都是空同通道则为真，否则为假
    return QuEmpty(&obj->q1)&&QuEmpty(&obj->q2);
}
//销毁
void myStackFree(MyStack* obj) {
    QuDestroy(&obj->q1);
    QuDestroy(&obj->q2);
    free(obj);
    obj = NULL;
}

 关于销毁：要先从小（从内向外）的开始，我们应该先从q1和q2进行销毁，在销毁obj

obj申请的空间是为2个队列开辟的，2个队列申请的空间又是为里面的单链表开辟的，你直接销毁大哥，小弟起步就是群龙无首，变成了“野狗”

二、用栈实现队列：

1、题目:

223cd369447d0410cad2cce24a6a26447.png

2、思路：

和上面思路大差不差

先画图：和上面说的类似，不做赘述

b69501cbeb4f4a33a6f8b44b5001e528.png

 区别1：栈的top指向的是  栈顶元素   还是  栈顶元素下一个位置

根据之前我写的top指向的是栈顶元素的下一个位置叙说：如下

没有数据是top = 0；当存入一个时top = 1；

4748e8bc1d484d5f982b4e29d9351807.png

 af765a10d7494fcb9dad3d46826fb0f1.png

 所以你再取数据放到空的栈时应该也要注意先pop一下再取

 还有一个需要注意的点：它比队列实现栈跟倔强（醒悟的更慢）！！！

一个栈里面的数据如下：

04cff4a000bd4378b877afd5f1568bca.png

 4 3 2 取出放到下面的空栈中

 流程图如下:1 就顺利走了，以为这样就完事了？？一开始我也这样想的，结果碰壁了

e627c9bb9bbb4ae19b040ef66478db1f.png

将1取走后，根据之前的思路，再pop时就会将3 2放到上面栈，那么最后出队顺序变成了：1 4 2 3

乱套了

非常不对劲

 我想到了再回转一次，这样就可以保证我开始入队时的顺序不变，也就是将上面的栈作为出数据用，每次出一次数据，就将其他数据入栈到下面的栈，出完再回到上面的栈，无论你423519e7ecb74c08b99aa6daccc1ccb5.png

可以理解为：不撞南墙不回头（心死了，才向前）！！！！头比较硬哈，越靠后撞的次数越多

9426bce6cbeb4acf8c687ee868f426b1.png

 3、代码：

有更好的代码，作参考即可

typedef int LTDataType;
//顺序表（栈）
typedef struct SL
{
	LTDataType* a;
	int top;
	int capacity;
}SL;
//入栈
void SLPush(SL* p,LTDataType x)
{
	//不能传NULL,判空;
	assert(p);
	if (p->top == p->capacity)
	{
		//先判断是否为0，好进行扩容
		int newnode = p->capacity == 0 ? 4 : 2 * (p->capacity);
		//扩容；创建一个临时变量接收新的空间，成功在将其交给p->a；
		LTDataType* s = (LTDataType*)realloc(p->a,newnode * sizeof(LTDataType));
		if (s == NULL)
		{
			perror("realloc");
			return;
		}
		p->a = s;
		p->capacity = newnode;
	}
	p->a[p->top] = x;
	//指向下一个数据地址
	p->top++;
}
//出栈(类似尾删)
void SLPop(SL* p)
{
	//是否为空
	assert(p);
	assert(p->top > 0);
	p->top--;
}
//初始化
void SLInit(SL* p)
{
	p->a = NULL;
	p->capacity = 0;
	//p->top = -1;//指向栈顶的数据
	p->top = 0;//指向栈顶的下一个数据
}
//销毁
void SLDestroy(SL* p)
{
	assert(p);
	free(p->a);
	p->a = NULL;
	p->capacity = p->top = 0;
}
//判空
bool SLEmpty(SL* p)
{
	//不能是空地址
	assert(p);
	//为0就是真(true)，为1就是假(flase)
	return p->top == 0;
}
//数据个数
int SLsize(SL* p)
{
	int size = p->top;
	return size;
}
//取数据：
LTDataType SLPot(SL*p)
{
	assert(p);
	return p->a[p->top];
}

//2个栈
typedef struct {
    SL q1;
    SL q2;
} MyQueue;

//初始化
MyQueue* myQueueCreate() {
    MyQueue*pts = (MyQueue*)malloc(sizeof(MyQueue));
    if(pts==NULL)
    {
        perror("malloc");
        return NULL;
    }
    SLInit(&pts->q1);
    SLInit(&pts->q2);
    return pts;
}
//入队
void myQueuePush(MyQueue* obj, int x) {
    //非空，存数据:一定要注意top，我的top是指向栈顶元素的下一个位置
    if(!SLEmpty(&obj->q1))
    {
        SLPush(&obj->q1,x);
    }
    else
    {
        SLPush(&obj->q2,x);
    }
}
//出队
int myQueuePop(MyQueue* obj) {
    //假设法：
    SL *noEmpty =&obj->q1;
    SL *empty =&obj->q2;
    if(!SLEmpty(empty))
    {
        noEmpty =&obj->q2;
        empty =&obj->q1;
    }
    while(SLsize(noEmpty)>1)
    {
        //根据top指向位置要先pop
        SLPop(noEmpty);
        int x = SLPot(noEmpty);
        SLPush(empty,x);
    }
    SLPop(noEmpty);
    int Top = SLPot(noEmpty);
    while(!SLEmpty(empty))
    {
        //根据top指向位置要先pop
        SLPop(empty);
        int x = SLPot(empty);
        SLPush(noEmpty,x);
    }
    return Top;
}
//取
int myQueuePeek(MyQueue* obj) {
    SL*qq1 = &obj->q1;
    SL*qq2 = &obj->q2;
    //直接取第一个进去的数据
    if(!SLEmpty(qq1))
    {
        return qq1->a[0];
    }
    else
    {        
        return qq2->a[0];
    }

}
//判空
bool myQueueEmpty(MyQueue* obj) {
    return SLEmpty(&obj->q1)&&SLEmpty(&obj->q2);
}
//销毁
void myQueueFree(MyQueue* obj) {
    SLDestroy(&obj->q1);
    SLDestroy(&obj->q2);
    free(obj);
    obj = NULL;
}

 三、设计循环队列:

粗略讲解一下：循环队列

循环队列是一种线性数据结构。它也被称为“环形缓冲器”，大致就是一个队列有了空间大小，这个空间只能存出的数据是有限个，满了不能存，未满则可以继续存，相当于苍蝇馆吃饭，比较火爆，只能坐下k个人，那么就得排队，若是离开一个，就能进去一个，接着走

bf14b081bb4149cba654f13db4ca3ff9.jpeg

 

1、题目：

 e9c47ad1ff7e44e7ab8d584c01ec78de.png

 2、思路：

有链表和顺序表（数组）都可以实现，我用的数组，因为更简单一点：

根据上面的介绍可以知道，循环列队要一个标记首和尾的变量（head和tail）

初状态:都在头的位置，下标来看的话就是  0 的位置

561a3f3393cc48bdba993217c51e359f.png

检查队列满和空的情况：

空的情况：很简单，就是head = tail

561a3f3393cc48bdba993217c51e359f.png

满队时，tail应该指向的下一个位置，存一个数据tail后移一位，所以如下：4个数据的空间，满队时，刚好 tail = k（k表示数据个数（空间大小））要判满的话  也是tail==head才行，

tail%k==head；   但是这么做的话有问题：空也是head == tail，这不是冲突么！ 

9f281058de4d47a399f2c0230ca9ed1c.png

有2种方法：任选，操作难度差不多

1、设置size ——记下数据个数

2、多创建一个空间

当满栈时，tail与head差了一步，我们写下 （tail+1）%（k+1）；有点抽象，看下面

 

f857985830494420ac871ced97884091.png

给它用环来看：是不是更清晰了，头和尾的差了一个 1也就是tail+1；因为数组是一块连续的空间，所以我们要用%(k+1)将尾和头相连 

82c94e27718342fba491a17f9b21087e.png

插入数据时，需要注意tail的取值：

 先存数据再给tail = tail+1；但是tail不能一直往后走的（循环规定了循环的范围）！！！！它的取值只能是[0,k];所以要写一个tail %=（k+1）;  因为x%k  (取值为：0 —— k-1)

8e3a8a6d4df2454da00195060cd22077.png

85a1a3b482494cf5bb9b70620756f659.png

 若是数据如此：tail是在下标为5的位置，后面是不能用的，所以要将tail传回到头去，保证了差一步（保证了一个空间不能用，因为我们多申请了一个，这个空间只是饰品，不能用）0c408bcde52c46c9bf9c976e1320c07e.png

 

取尾元素：

 tail的位置是下一个元素的位置，所以要用tail-1来调用，但是有坑，当tail的位置到达了下标0处，还能减掉吗？？？那不就是-1么，但是我们要的取的值tail-1的范围应该是[o,k]这个区间范围内

e64c62838c164f0cbbc7c2ff00a553aa.png

上面我们是  tail = tail%（k+1）;——>>> tail-1 = tail%（k+1)-1;

我们要将它区间变成[0,k];  变形：

461a8fd2d36b456fbd350804d1c813c3.png

 

3、代码：

typedef struct {
    int *a;
    int head;
    int tail;
    int k;
} MyCircularQueue;
//因为在判空和判满的上面的函数需要调用他俩，所以我们要进行函数声明
bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueIsEmpty(MyCircularQueue* obj);

//初始化：
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*pts = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if(pts==NULL)
    {
        perror("malloc");
        return NULL;
    }
    pts->a = (int*)malloc(sizeof(int)*(k+1));
    if(pts->a==NULL)
    {
        perror("malloc");
        return NULL;
    }

    pts->k = k;
    pts->tail = pts->head =0;
    return pts;
}

//插入，返回真假
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //是否为满，满了就不能插入；
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->tail]= value;
        obj->tail++;
        obj->tail%=(obj->k+1);
        return true;
    }

}
//删除：返回真假
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
   //是否为空，为空不能删除
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->head++;
        obj->head%=(obj->k+1);
        return true;
    }
}
//取头元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->head];
    }
}
//取尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[(obj->tail-1+obj->k+1)%(obj->k+1)];
    }
}
//s是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head == obj->tail;
}
//是否满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->head == (obj->tail+1)%(obj->k+1);
}
//销毁
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a =NULL;
    free(obj);
    obj = NULL;

}

 

 

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

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

相关文章

【Linux】什么是进程？

【Linux】什么是进程？

一个正在执行的程序，我们称之为进程。 然后我们来顺着一条线来思考。 操作系统底层是用C语言编写的，而我们的进程，它会有各种属性，那么各种属性就可以用一个结构体来对进程的各个属性进行描述，然后这个结构体里面&…
阅读更多...
C语言 6 函数

C语言 6 函数

目录 1. 函数的概念 2. 库函数 标准库和头文件 库函数的使用方法 库函数⽂档的一般格式 3. 自定义函数 函数的语法形式 函数的举例 4. 形参和实参 实参 形参 实参和形参的关系 5. return语句 6. 数组做函数参数 7. 嵌套调用和链式访问 嵌套调用 链式访问 8. 函数的声明和定义 单…
阅读更多...
Spring MVC分页示例

Spring MVC分页示例

Spring MVC分页示例 分页用于在不同部分显示大量记录。在这种情况下，我们将在一页中显示10、20或50条记录。对于其余记录，我们提供链接。 我们可以在Spring MVC中简单地创建分页示例。在此分页示例中，我们使用MySQL数据库来获取记录。 创建…
阅读更多...
Python爬虫实战：爬取【某旅游交通出行类网站中国内热门景点】的评论数据,使用Re、BeautifulSoup与Xpath三种方式解析数据，代码完整

Python爬虫实战：爬取【某旅游交通出行类网站中国内热门景点】的评论数据,使用Re、BeautifulSoup与Xpath三种方式解析数据，代码完整

一、分析爬取网页： 1、网址 https://travel.qunar.com/2、 打开网站，找到要爬取的网页 https://travel.qunar.com/p-cs299979-chongqing进来之后，找到评论界面，如下所示：在这里我选择驴友点评数据爬取点击【驴友点评…
阅读更多...
【机器学习】 人工智能和机器学习辅助决策在空战中的未来选择

【机器学习】 人工智能和机器学习辅助决策在空战中的未来选择

🚀传送门 🚀文章引言🔒技术层面📕作战结构🌈替代决策选项🎬选项 1：超级战争（Hyperwar）🌠选项 2：超越OODA🌂选项 3：阻止其他…
阅读更多...
Linux 认识与学习Bash——3

Linux 认识与学习Bash——3

在Linux bash中&#xff0c;数据流重定向是指将命令的输出从默认的标准输出&#xff08;通常是终端&#xff09;重定向到其他位置&#xff0c;如文件或另一个命令的输入。这是通过使用特定的符号来实现的。例如&#xff0c;>用于将输出重定向到文件&#xff0c;而<用于将…
阅读更多...
使用 AI Assistant for Observability 和组织的运行手册增强 SRE 故障排除

使用 AI Assistant for Observability 和组织的运行手册增强 SRE 故障排除

作者&#xff1a;Almudena Sanz Oliv, Katrin Freihofner, Tom Grabowski 通过本指南&#xff0c;你的 SRE 团队可以实现增强的警报修复和事件管理。 可观测性 AI 助手可帮助用户使用自然语言界面探索和分析可观测性数据&#xff0c;利用自动函数调用来请求、分析和可视化数据…
阅读更多...
【35分钟掌握金融风控策略18】贷前风控策略详解-3

【35分钟掌握金融风控策略18】贷前风控策略详解-3

目录 ​编辑 贷前风控数据源 第三方数据 贷前风控数据源 第三方数据 在金融风控过程中&#xff0c;金融机构通常会引入一些第三方的风控数据&#xff08;或第三方金融技术&#xff09;来辅助识别贷款个人或贷款企业的风险状况&#xff0c;帮助金融机构进行风控决策&#x…
阅读更多...
MySQL·表的内外连接

MySQL·表的内外连接

目录 表的内连和外连 内连接 案例1&#xff1a;显示SMITH的名字和部门名 外连接 左外连接 案例2&#xff1a; 查询所有学生的成绩&#xff0c;如果这个学生没有成绩&#xff0c;也要将学生的个人信息显示出来 右外连接 案例3&#xff1a;对stu表和exam表联合查询&#…
阅读更多...
【话题】你用过最好用的AI工具有那些

【话题】你用过最好用的AI工具有那些

大家好&#xff0c;我是全栈小5&#xff0c;欢迎阅读小5的系列文章&#xff0c;这是《话题》系列文章 目录 背景一、C知道二、CSDN工具集三、AI工具的普及与受欢迎程度四、AI工具的实际应用与影响五、总结与展望文章推荐 背景 探讨人们在使用AI工具时&#xff0c;最喜欢的和认…
阅读更多...
栈和队列初级题目（包含四个题）

栈和队列初级题目（包含四个题）

目录 一、原题链接&#xff1a; 二、有效的括号&#xff1a; ​编辑代码实现&#xff1a; 三、用队列实现栈&#xff1a; 四、用栈实现队列&#xff1a; 五、设计循环队列&#xff1a; 六、读书分享&#xff1a; 一、原题链接&#xff1a; 20. 有效的括号 225. 用队列实…
阅读更多...
Linux 进程信号【信号产生】

Linux 进程信号【信号产生】

&#x1f493;博主CSDN主页:麻辣韭菜&#x1f493;   ⏩专栏分类&#xff1a;Linux知识分享⏪   &#x1f69a;代码仓库:Linux代码练习&#x1f69a;   &#x1f339;关注我&#x1faf5;带你学习更多Linux知识   &#x1f51d; 目录 前言 信号概念 1. 生活角度的信号 2…
阅读更多...
线性代数的一些理解（更新中）

线性代数的一些理解（更新中）

以前学的时候都是囫囵吞枣&#xff0c;能搞过就得了。现在有了点时间可以静下来看看。。 还是分成点来看吧。 1 小车运行 一个车匀速在一维坐标前行&#xff0c;速度是2米每秒&#xff0c;起始点是0。如何描述 设 &#x1d465;(&#x1d461;) 表示车辆在时间 &#x1d461…
阅读更多...
为什么要进行金融类软件测试

为什么要进行金融类软件测试

金融类软件测试是确保金融软件质量、安全性和稳定性的关键步骤。随着金融行业信息化和数字化的深入发展&#xff0c;金融软件的应用范围日益广泛&#xff0c;涉及资金交易、客户信息管理、风险控制等多个方面。 因此&#xff0c;进行金融类软件测试显得尤为重要&#xff0c;以…
阅读更多...
力扣HOT100 - 155. 最小栈

力扣HOT100 - 155. 最小栈

解题思路&#xff1a; 辅助栈 class MinStack {private Stack<Integer> stack;private Stack<Integer> min_stack;public MinStack() {stack new Stack<>();min_stack new Stack<>();}public void push(int val) {stack.push(val);if (min_stack.i…
阅读更多...
24数维杯ABC题思路已更新！！！！

24数维杯ABC题思路已更新！！！！

24数维杯A题保姆级思路&#xff0b;配套代码&#xff0b;后续参考论文 简单麦麦https://www.jdmm.cc/file/2710639/ 24数维杯B题保姆级思路&#xff0b;可执行代码&#xff0b;后续参考论文 简单麦麦https://www.jdmm.cc/file/2710640/ 24数维杯C题保姆级思路&#xff0b;可执…
阅读更多...
[AutoSar]BSW_Com021单帧 首帧 流控帧 连续帧 详解

[AutoSar]BSW_Com021单帧 首帧 流控帧 连续帧 详解

目录 关键词平台说明一、N_PDU和N_PCI二、单帧三、首帧四、流控帧五、连续帧六、case 关键词 嵌入式、C语言、autosar、OS、BSW、UDS、diagnostic 平台说明 项目ValueOSautosar OSautosar厂商vector &#xff0c; EB芯片厂商TI 英飞凌编程语言C&#xff0c;C编译器HighTec (…
阅读更多...
2024全新小狐狸AI免授权源码

2024全新小狐狸AI免授权源码

源码安装说明&#xff1a; 下 载 地 址 &#xff1a; runruncode.com/php/19757.html 1. 在宝塔新建一个站点&#xff0c;选择 PHP 版本为 7.2、7.3 或 7.4。将压缩包上传到站点的根目录&#xff0c;并设置运行目录为 /public。 2. 导入数据库文件&#xff0c;该文件位于 …
阅读更多...
【JVM】从三种认知角度重识JVM

【JVM】从三种认知角度重识JVM

目录 JVM概述 JVM主要功能 虚拟机是Java平台无关的保障 JVM概述 JVM&#xff1a;Java Virtual Machine,也就是Java虚拟机。 虚拟机&#xff1a;通过软件模拟的具有完整硬件系统功能的、运行在一个完全隔离环境中的计算机系统&#xff08;物理上不存在&#xff09;。 JVM通…
阅读更多...
求一个B站屏蔽竖屏视频的脚本

求一个B站屏蔽竖屏视频的脚本

求一个B站屏蔽竖屏视频的脚本 现在B站竖屏竖屏越来越多了&#xff0c;手机还好点给我一个按钮&#xff0c;选择不喜欢&#xff0c;但是我一般都用网页版看视屏&#xff0c;网页版不给我选择不喜欢的按钮&#xff0c;目测大概1/4到1/3的视频都是竖屏视频。 目前网页版唯一的进…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023