栈和队列OJ题讲解

news2024/11/25 2:53:40

💓博主个人主页:不是笨小孩👀
⏩专栏分类:数据结构与算法👀 刷题专栏👀 C语言👀
🚚代码仓库:笨小孩的代码库👀
⏩社区：不是笨小孩👀
🌹欢迎大家三连关注，一起学习，一起进步！！💓

在这里插入图片描述

OJ题

  • 用队列实现栈
  • 用栈实现队列
  • 设计循环队列

用队列实现栈

在这里插入图片描述

队列是先进先出，而栈是先进后出，那我们怎么用两个队列来实现一个栈呢？

我们想要出数据的话，由于要实现的是栈，所以要后进先出，所以我们需要出4，但是由于他是队列，只能出1，但是我们有两个队列，我们假设队列一中有size个数据，那我们只需要将size-1个都放到另一个队列里面，然后在出掉最后一个就可以了。

在这里插入图片描述

如果需要入数据的话，我们就在不为空的那个队列后面入数据。
大概思想知道以后，我们就可以上手写代码了。（由于C语言没有队列，所以我们需要先拷贝一份我们之前写好的队列）

typedef int QDataType;

typedef struct QNode
{
	QDataType date;
	struct QNode* next;
}QNode;


typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

//初始化队列
void QueueInit(Queue* pq);

//入队列
void QueuePush(Queue* pq, QDataType x);

//出队列
void QueuePop(Queue* pq);

//获取队头的元素
QDataType QueueFront(Queue* pq);

//获取队头尾的元素
QDataType QueueBack(Queue* pq);

//获取队列中有效数据的个数
int QueueSize(Queue* pq);

//判断队列是否为空
bool QueueEmpty(Queue* pq);

//销毁队列
void QueuDestroy(Queue* pq);

//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

//入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->date = x;
	newnode->next = NULL;

	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}

//出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}	

	pq->size--;
}

//获取队头的元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->head->date;
}

//获取队头尾的元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->tail->date;
}

//获取队列中有效数据的个数
int QueueSize(Queue* pq)
{
	assert(pq);
	
	return pq->size;
}

//判断队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->size == 0;
}

//销毁队列
void QueuDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;

}

//上面是我们自己的队列
//
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() 
{
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x) 
{
	//Push到不为空的队列中
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) 
{
	//假设q1不为空
	Queue* noEmpty = &obj->q1;
	Queue* Empty = &obj->q2;
	//如果假设错误，修改
	if(QueueEmpty(&obj->q1))
	{
			noEmpty = &obj->q2;
			Empty = &obj->q1;
	}
	//到数据
	int x = QueueFront(noEmpty);
	while(noEmpty->size>1)
	{
			QueuePush(Empty,x);
			QueuePop(noEmpty);
			x = QueueFront(noEmpty);
	}
	//此时x就保存了最后一个数据，pop掉，返回就可以
	QueuePop(noEmpty);
	return x;
}

int myStackTop(MyStack* obj) 
{
	//返回不为空的队列的尾
	if(QueueEmpty(&obj->q1))
	{
		return QueueBack(&obj->q2);
	}
	else
	{
		return QueueBack(&obj->q1);
	}
}

bool myStackEmpty(MyStack* obj) 
{
	//两个队列都为空，栈才为空
	return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) 
{
	QueuDestroy(&obj->q1);
	QueuDestroy(&obj->q2);
	free(obj);
}

本题逻辑比较简单，但是结构很强，需要好好理解消化。

用栈实现队列

在这里插入图片描述

这个题和第一个题很相似，是用两个栈实现一个队列。

那这又怎么操作呢？

我们同样push数据时，如果两个都为空的话都可以push，但是如果出数据的话，由于需要先进先出，所以需要将不为空的那个栈的数据放到另一个栈中。

在这里插入图片描述

接下来另一个栈的数据是不是就满足我们需要的顺序了，正好1先进的1先出，接着是2,3,4,那如果没出的话接着push数据呢，我们只需要将数据还push到原来的呢个栈，这是我们不难发现只要当第二个栈的数据出完之后，然后将原本那个栈的数据倒过来就可以了。这个个队列不一样的是，不用每次都倒数据，我们可以将第一个栈叫push栈，第二个栈叫pop栈，然后当pop栈为空时，就将数据倒过来，接着出就可以了，如果两个栈都空了，那说明我们的队列就空了。

代码如下;

typedef int STDateType;

typedef struct Stack
{
	STDateType* arr;
	int top;
	int capacity;
}Stack;

// 初始化栈
void StackInit(Stack* ps);

// 入栈
void StackPush(Stack* ps, STDateType x);

// 出栈
void StackPop(Stack* ps);

// 获取栈顶元素
STDateType StackTop(Stack* ps);

// 获取栈中有效元素个数
int StackSize(Stack* ps);

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
bool StackEmpty(Stack* ps);

// 销毁栈
void StackDestroy(Stack* ps);

// 初始化栈
void StackInit(Stack* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

// 入栈
void StackPush(Stack* ps, STDateType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDateType* pa = (STDateType*)realloc(ps->arr, newcapacity * sizeof(STDateType));
		if (ps == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->arr = pa;
		ps->capacity = newcapacity;
	}
	ps->arr[ps->top] = x;
	ps->top++;
}

// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps ->top > 0);
	ps->top--;
}

// 获取栈顶元素
STDateType StackTop(Stack* ps)
{
	assert(ps);

	return ps->arr[ps->top - 1];
}

// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

// 检测栈是否为空
bool StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0 ? true : false;
}

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);

	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
//我们自己的栈
/
typedef struct 
{
    Stack Stackpush;
    Stack Stackpop;
} MyQueue;


MyQueue* myQueueCreate() 
{
    MyQueue* obj= (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->Stackpush);
    StackInit(&obj->Stackpop);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) 
{
    StackPush(&obj->Stackpush,x);
}

int myQueuePeek(MyQueue* obj) 
{
	//如果Pop栈为空就倒数据
    if(StackEmpty(&obj->Stackpop))
    {
        while(!StackEmpty(&obj->Stackpush))
        {
            StackPush(&obj->Stackpop,StackTop(&obj->Stackpush));
            StackPop(&obj->Stackpush);
        }
    }
    return StackTop(&obj->Stackpop);
}

int myQueuePop(MyQueue* obj) 
{
    //调用返回队头的元素，并且判断了Pop栈是否为空
    int x = myQueuePeek(obj);
    StackPop(&obj->Stackpop);
    return x;
}



bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->Stackpop)&&StackEmpty(&obj->Stackpush);
}

void myQueueFree(MyQueue* obj) 
{
    StackDestroy(&obj->Stackpop);
    StackDestroy(&obj->Stackpush);
    free(obj);
}

这两个题逻辑非常简单，但是都对我们对结构的了解有很大的挑战。

设计循环队列

在这里插入图片描述

循环队列我们也可以用数组实现，也可以用链表实现，但是使用链表我们构造链表也是一件很麻烦的事情，而且当队列满时和队列空时情况一样，我们会很难区分，但是用链表也是可以实现的，但是我们这里介绍用数组实现。

我们这里需要K个空间，但是我们多开一个空间不存储数据，方便我们来区别空和满的情况。

在这里插入图片描述
我们可以看到空队列时front是和rear相等的。

在这里插入图片描述
当满队列时rear+1就等于front了。

设计这个循环队列，当rear超过K+1是我们就要让他回到0出，我们可以用if判断，也可以用取模操作。我们入数据就在rear位置入，出数据只需要将front++就可以了但是front也可能会越界。所以也需要取模操作。

在这里插入图片描述
这种情况front就可能越界，所以在写代码是要控制好边界。

代码如下：

typedef struct 
{
    int* a;
    int front;
    int rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* Mq = ( MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    Mq->a = (int*)malloc(sizeof(int)*(k+1));
    Mq->front = 0;
    Mq->rear = 0;
    Mq->k = k;
    return Mq;
}


bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->front==obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    return (obj->rear+1)%(obj->k+1)==obj->front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->rear] = value;
    obj->rear++;
    obj->rear = obj->rear%(obj->k+1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }

    obj->front++;
    //防止front越界
    obj->front = obj->front%(obj->k+1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
   //obj->read==0的话应该是返回k那个位置的
    return obj->rear==0?obj->a[obj->k]:obj->a[obj->rear-1];
}


void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

今天的分享就到这里结束了，感谢大家的关注和支持。

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

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

相关文章

mysql事务隔离级别详细讲解

mysql事务隔离级别详细讲解

mysql事务讲解 MySQL事务处理（TransAction） 大家好，我是一名热爱研究技术并且喜欢自己亲手实践的博主。 工作这么多年，一直没有深入理解MySQL的事务，因为最近也在面试，准备复习mysql的相关知识&#xff0…
阅读更多...
verilog 实现异步fifo

verilog 实现异步fifo

理论知识参考 异步FIFO_Verilog实现_verilog实现异步fifo_Crazzy_M的博客-CSDN博客 代码 /* 位宽8bit, 位深8 */ module async_fifo#(parameter FIFO_DEPTH 8,parameter FIFO_WIDTH 8 ) (input rst_n,input wr_clk,input wr_en,input [FIFO_WIDTH - 1:0…
阅读更多...
数据结构之红黑树

数据结构之红黑树

二叉搜索树对于某个节点而言，其左子树的节点关键值都小于该节点关键值，右子树的所有节点关键值都大于该节点关键值。二叉搜索树作为一种数据结构，其查找、插入和删除操作的时间复杂度都为O(logn),底数为2。但是我们说这个时间复杂度是在平衡的…
阅读更多...
C#小轮子 Debug,Release,发布模式如何运行不同的代码

C#小轮子 Debug,Release,发布模式如何运行不同的代码

文章目录 前言C#运行模式运行模式介绍三种模式区分代码 前言 编译模式和发布模式的代码不一样是非常正常的。比较常见的是数据库不一样。编译测试数据库和发布真实的数据库地址不一样。 C#运行模式 运行模式介绍 运行模式有三种： Debug 不进行优化，…
阅读更多...
逆向破解学习-经典贪吃蛇大作战_1.00

逆向破解学习-经典贪吃蛇大作战_1.00

试玩游戏 有支付取消关键字 找静态代码 找到关键字 ![在这里插入图片描述](https://img-blog.csdnimg.cn/5d9f3cc57d18477794197ea5fae8c5ba.png Hook代码 import de.robv.android.xposed.XC_MethodHook; import de.robv.android.xposed.XC_MethodReplacement; import de.r…
阅读更多...
MyBatis操作数据库常用用法总结1

MyBatis操作数据库常用用法总结1

文章目录 1.单表查询1.1返回所有的表记录1.2根据id查找结果1.3根据名字查找结果 2.单表修改2.1修改密码 3.单表删除3.1根据id删除信息 4.单表增加（根据业务情况返回）4.1添加返回影响的行数4.2添加返回影响行数和id 5.多表查询（多）…
阅读更多...
网易云信回声消除量化评估方法

网易云信回声消除量化评估方法

背景 随着现代通信技术的发展，语音通信成为了人们生活中不可或缺的一部分。然而，环境噪声和回声等因素对语音通信质量产生了不良影响，降低了通信效率和用户体验，声学回声消除技术的应用变得越来越重要。如何评估回声消除的效果也变…
阅读更多...
详解如何计算字符中的字节数

详解如何计算字符中的字节数

文章目录 字符概念转义 进制的表示前缀区分后缀区分 什么是ASCII产生表述局限性字节计算 什么是Unicode编码方式UCS-2UCS-4 实现方式UTF的字节序和BOM字节计算 JavaScript中使用字符字符使用缺陷规避字符使用缺陷 MIME 编码Base64编码字节计算QP(Quote-Printable) 总结 字符概念…
阅读更多...
进阶-LayUI的基本必知入门教程使用3-layui-laydate选择的值怎么获取？苟日新一刻钟总结反观：

进阶-LayUI的基本必知入门教程使用3-layui-laydate选择的值怎么获取？苟日新一刻钟总结反观：

1 效果镇楼： 对于layui框架的刚接触没几天，但是您的年轻同事为啥能搞出来功能啊！？ 到您就不行了呢？ 这就是您对您饭碗的态度了吗！ 但是，是您尽力了，还能说明啥子问题？ 就…
阅读更多...
SOLIDWORKS自动标注插件

SOLIDWORKS自动标注插件

在设计工作中，三维模型设计好之后，还要创建二维工程图，用来指导加工生产。二维图出图的过程是一个非常枯燥的过程，而且还需要根据公司规范来进行尺寸标注、公差标注等，所以有时候，可能建模只用了几分钟&…
阅读更多...
在UOS系统中管理ORACLE数据库

在UOS系统中管理ORACLE数据库

在明确了“数字中国”建设战略后。自主创新与国产化已成为我国实现科技强国、经济强国的发展趋势与行业共识。 即信息技术应用创新产业，简称“信创”。 而现有的国产操作系统，虽然已日趋成熟，但因为很多应用软件由国外垄断，因此…
阅读更多...
一键获取数百张免费商用人脸!AI人脸生成器来袭

一键获取数百张免费商用人脸!AI人脸生成器来袭

随着科技的发展，人工智能正在渗透到生活的各个角落，设计行业也不例外。在网页、APP、PPT 等界面设计中，设计师经常需要插入真实的人脸素材，以增强作品的真实感和场景化。但是获取素材既不容易，质量和价格也难免成为设计…
阅读更多...
PK Nounique CASCADE DROP INDEX keep index

PK Nounique CASCADE DROP INDEX keep index

Explicit Control Over Indexes when Creating, Disabling, or Dropping PK/Unique Constraints (Doc ID 139666.1)​编辑To Bottom PURPOSEIn Oracle 9i, the DBA has an explicit control over how indexes are affectedwhile creating, disabling, or dropping Primary Ke…
阅读更多...
【网络基础实战之路】基于BGP协议连接三个AS区域的实战详解

【网络基础实战之路】基于BGP协议连接三个AS区域的实战详解

系列文章传送门： 【网络基础实战之路】设计网络划分的实战详解 【网络基础实战之路】一文弄懂TCP的三次握手与四次断开 【网络基础实战之路】基于MGRE多点协议的实战详解 【网络基础实战之路】基于OSPF协议建立两个MGRE网络的实验详解 【网络基础实战之路】基于…
阅读更多...
网页版的微信客户管理系统是怎样的？

网页版的微信客户管理系统是怎样的？

登录账号密码： 微信扫码登录到系统上： 支持多个微信号登录到系统，聚合管理聊天，可以快速查看客服号的聊天记录 群发助手：群发可突破200 朋友圈功能：定时发圈，支持多个微信账号同步发圈、跟圈和一…
阅读更多...
恒运资本：投资前瞻：储能产业迎政策密集支持 AIGC有望进入加速状态

恒运资本：投资前瞻：储能产业迎政策密集支持 AIGC有望进入加速状态

昨日，沪指、深成指盘中弱势下探，创业板指冲高回落。到收盘，沪指跌0.49%报3244.49点，深成指跌0.53%报11039.45点，创业板指微跌0.01%报2228.73点，科创50指数跌0.85%；两市合计成交7366亿元&#xf…
阅读更多...
STM32 F103C8T6学习笔记4：时钟树、滴答计时器、定时器定时中断

STM32 F103C8T6学习笔记4：时钟树、滴答计时器、定时器定时中断

今日理解一下STM32F103 C8T6的时钟与时钟系统、滴答计时器、定时器计时中断的配置，文章提供原理，代码，测试工程下载。 目录 时钟树与时钟系统： 滴答计时器： 定时器计时中断： 测试结果： 测…
阅读更多...
echarts3d柱状图

echarts3d柱状图

//画立方体三个面 const CubeLeft echarts.graphic.extendShape({shape: {x: 0,y: 0,width: 9.5, //柱状图宽zWidth: 4, //阴影折角宽zHeight: 3, //阴影折角高},buildPath: function (ctx, shape) {const api shape.api;const xAxisPoint api.coord([shape.xValue, 0]);con…
阅读更多...
OSCS 闭门研讨第一期实录：软件供应链安全建设价值

OSCS 闭门研讨第一期实录：软件供应链安全建设价值

2023 年 7 月 18 日晚 19:30，软件供应链安全技术交流群（OSCS）组织了第一次线上的闭门研讨会，本次研讨会我们收到 71 个来自各个企业关注软件供应链安全的技术专家的报名，根据研讨会参与规则要求，我们对报名…
阅读更多...
一文告诉你，Intellij IDEA神器隐藏的11种实用小技巧！

一文告诉你，Intellij IDEA神器隐藏的11种实用小技巧！

el/2022/10/4 6:58:50 点击上方“程序员大咖”，选择“置顶公众号” 关键时刻，第一时间送达！ Intellij IDEA真是越用越觉得它强大，它总是在我们写代码的时候，不时给我们来个小惊喜。出于对Intellij IDEA的喜爱&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023