leetcode栈和队列三剑客

news2025/1/10 17:08:32

在这里插入图片描述
用队列实现栈

在这里插入图片描述
队列是先进先出的，而栈是只能在栈顶进行出栈和入栈，那我们这道题要用队列来实现栈的话，这里给的思路是两个队列，因为两个队列的话就可以相互导数据，比如我们来实现这个题目的push函数，我们的栈是只能在栈顶进行操作，那其实插入就也可以在队列的尾部进行插入，但是我们是两个队列，我们不能在空的队列进行插入，这样顺序就会乱，所以我们这里需要做的就是在不是空的队列进行插入操作。

在这里插入图片描述
那如果我们的栈要实现出栈该怎么做呢，我们先来看一下下面的这个图。

在这里插入图片描述
我们这里的出栈不是出第一个元素1，而是想办法把我们这里第一个队列的4出去，那因为队列只能在头上进行pop那我们这里可以先把第一个队列的前三个数据导入到第二个队列中，然会在pop第一个队列就可以了。代码实现就是下面这个图

在这里插入图片描述
我们的队列是始终保持一个是有数据的，一个是为空的，比如我们如果是取栈顶的元素，这里我们是确保取出不为空的队列数据的front，所以这个函数来实现也是特别的简单。

在这里插入图片描述
这道题的整个代码思路就是下面（我们这里用的是C语言，所以要自己实现一个队列）


#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int QDataType;

typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);







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


}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->data = data;
	if (q->head == NULL)
	{
		q->head = q->tail = newnode;

	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(q->size >= 0);
	assert(q->head != NULL);
	QNode* del = q->head;
	q->head = q->head->next;
	free(del);
	del = NULL;
	if (q->head == NULL)
		q->tail = NULL;
	q->size--;
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->head);
	return q->head->data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->head);
	return q->tail->data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* q)
{
	assert(q);
	return q->head == NULL;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->head = q->tail = NULL;
}

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


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

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;
    if(QueueEmpty(nonempty))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }
    while(QueueSize(nonempty) > 1)
    {
        QueuePush(empty, QueueFront(nonempty));
        QueuePop(nonempty);
    }
    int ret = QueueFront(nonempty);
    QueuePop(nonempty);
    return ret;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
       return QueueEmpty(&obj->q1) &&  QueueEmpty(&obj->q2);

}

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

}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

用栈实现队列

在这里插入图片描述
有了前面的思路，我们知道栈的实现是要有两个队列才可以实现的，那同样我们如果要用栈实现队列的话，也得用两个栈来实现，这里我们的两个栈就有主要的区别，我们一个栈可以来当pop栈，还有一个栈可以当成push栈，这样的话，我们就有了分工的作用，后续在插入的时候我们只要在pop栈进行插入就可以了。

那我们先来实现一下我们该怎么初始化，初始化我们直接给两个栈

在这里插入图片描述
这里记住我们去初始化这俩个栈的时候我们是不知道该去怎么初始化，我们直接调用他们的函数就可以了，就不用去记住他们是怎么的一个样子。

在这里插入图片描述
那我们push就需要在push栈中push就可以了

在这里插入图片描述
这里的pop需要注意一些东西
如果popST为空，则将pushST的数据倒过来，就符合先进先出的顺序，如果不为空直接在栈顶进行pop就ok，但是我们这里如果一开始pop为空的，我们需要先把数据倒过来之后才可以进行下一部，我们前面就说过只有pop栈是pop的，push只是push，那我们就要进行判断，然会进行导数据这个操作。

在这里插入图片描述
下一个取出队列的元素，这个就很简单，就是复用上面的代码就可以，只是我们是取出来，不需要进行pop

那这道题就完成了，下面的就口函数我就直接给代码了（这里还是要自己实现一下栈）

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

静态实现（固定数组的长度）
//struct Stack
//{
//	int a[N];
//	int top; //栈顶的位置
//};


typedef int  STDataType;
//动态实现（固定数组的长度）
typedef struct Stack
{
	STDataType* a;   //传递数组地址，可以动态的进行扩容
	int top;   //栈顶的位置
	int capacity;   //容量
}ST;

//初始化
void StackInit(ST* ps);

//销毁
void StackDestory(ST* ps);

//压栈
void StackPush(ST* ps, STDataType x);

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

//判断栈是否为空
bool StackEmpty(ST* ps);

//计算栈的大小
int StackSize(ST* ps);

//初始化
void StackInit(ST* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;  //初始化top为0，则相当于从栈顶的下一个位置开始，则先赋值，再进行++操作
}


//销毁
void StackDestory(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;

	ps->capacity = 0;
	ps->top = 0;
}

//压栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	
	//如果当前的空间不够就需要进行扩容
	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		ps->a = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));
		if (ps->a == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		//当前的空间等于新的空间的大小
		ps->capacity = newCapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
	

}

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

//判断栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;  //判断它的顶部是否为0

}

//计算栈的大小
int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;   //返回栈顶就是元素的个数
}

//获取栈顶元素
STDataType StackTop(ST* ps)
{
	assert(ps);

	assert(ps->top > 0);

	return ps->a[ps->top - 1];   //top是栈顶的下一个元素，想找栈顶元素则进行减一的操作
}

//获取栈顶元素
STDataType StackTop(ST* ps);
typedef struct {
     ST pushST;
     ST popST;

} MyQueue;


MyQueue* myQueueCreate() {
   MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
   assert(obj);
   StackInit(&obj->pushST);
   StackInit(&obj->popST);

   return obj;
}

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

}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    //如果popST为空，则将pushST的数据倒过来，就符合先进先出的顺序
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }

    }
    int front =  StackTop(&obj->popST);
    StackPop(&obj->popST);

    return front;

}

int myQueuePeek(MyQueue* obj) {
    assert(obj);
    //如果popST为空，则将pushST的数据倒过来，就符合先进先出的顺序
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }

    }

    return  StackTop(&obj->popST);;

}

bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);

}

void myQueueFree(MyQueue* obj) {
     assert(obj);
    StackDestory(&obj->pushST);
    StackDestory(&obj->popST);

    free(obj);

}
/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

后面这个题比前面两道简单一点，是关于栈的。。

有效的括号

在这里插入图片描述
这个题我们用栈来实现，为什么用栈是因为这样时间复杂度就是O（N）我们只要遍历一遍就可以了，但是我们这个题目要知道考什么，一个我们必须数量进行匹配，另一个是顺序匹配，比如左括号（ 得和右）进行匹配，所以我们这里需要做的就是左括号这些入栈，然后右括号进行匹配，如果匹配成功的化原来里的括号要进行出栈，然会字符s往后继续++，但是如果有一个括号比右括号不是和我们的左括号匹配的话，我们需要进行的操作就是直接返回false就可以了，如果匹配成功的话出循环就是空栈，所以我们这里就可以直接返回true，但是还是有一个问题就是，在循环里面的时候，会出现越界访问

在这里插入图片描述
越界访问出现的情况就是有右括号，然后没有一个左括号在栈里面，我们这个取top的时候就可以直接返回。

下面是这个题的代码。


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

typedef char STDateType;
typedef struct Stack
{
	STDateType* a;
	int top;
	int capacity;
}ST;


void Init(ST* ps);

void Push(ST* ps, STDateType x);

void Pop(ST* ps);

STDateType Top(ST* ps);

void Dstory(ST* ps);

bool Empty(ST* ps);

int Size(ST* ps);


void Init(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = -1;
}

void Push(ST* ps, STDateType x)
{
	assert(ps);
	if (ps->top + 1 == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDateType* tmp =(STDateType*) realloc(ps->a, sizeof(STDateType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->capacity = newcapacity;
		ps->a = tmp;
	}
		ps->top++;

	ps->a[ps->top] = x;

}


void Pop(ST* ps)
{
	assert(ps);
	assert(ps->top >= 0);
	ps->top--;
}


void Dstory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->capacity = 0;
}

STDateType Top(ST* ps)
{
	assert(ps);
	assert(ps->top>=0);
	return ps->a[ps->top];
}


bool Empty(ST* ps)
{
	assert(ps);
	return ps->top == -1;
}




int Size(ST* ps)
{
	assert(ps);
	return ps->top + 1;
}

bool isValid(char* s) {
    ST st;
    Init(&st);
    while(*s)
    {
        if(*s == '(' || *s == '[' || *s == '{')
        {
            Push(&st, *s);
            s++;
        }
        else
        {
					if(Empty(&st))
					{
						return false;
					}
          char top = Top(&st);
					 Pop(&st);
					 if((*s == ')' && top != '(')|| (*s == ']' && top != '[')|| (*s == '}' && top != '{'))
            {
                return false;
            }
            s++;
        }
    }
    if(Empty(&st))
        return true;


    return false;
}

那今天三剑客就分享到这里，我们下次再见。

在这里插入图片描述

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

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

相关文章

面试其他注意事项

面试其他注意事项

面试其他注意事项 一、面试反问 这个岗位的日常工作和主要职责是什么&#xff1f;咱们这边主要负责什么业务&#xff0c;用到了哪些技术呢&#xff1f;对于我们校招生有没有培养体系呢&#xff1f;脱产培训&#xff0c;还是边工作边熟悉&#xff1f;会有导师带嘛&#xff1f;…
阅读更多...
飞书开发学习笔记(八)-开发飞书小程序Demo

飞书开发学习笔记(八)-开发飞书小程序Demo

飞书开发学习笔记(八)-开发飞书小程序Demo 一.小程序开发概述 1.1 小程序开发概述 飞书开发文档中查看&#xff1a;小程序开发概述 飞书小程序是指可以运行在飞书客户端中的小程序&#xff0c;小程序的一套代码可以适配 Android、iOS、PC 多平台&#xff0c;且用户体验与飞书…
阅读更多...
计算机多媒体

计算机多媒体

1&#xff0c;媒体、多媒体 2&#xff0c;体系结构 3&#xff0c;采样、编码
阅读更多...
公寓水电管理系统

公寓水电管理系统

springbootmybatisthymeleaf 这次练习是尝试将layer与系统结合起来&#xff0c;将新增、修改、删除都和弹窗结合起来。 一、需求分析 二、数据库 三、模块 1、登录页面 哈哈哈&#xff0c;之前做的登录页面都好丑&#xff0c;这是目前做的最好看的一次了。 超级管理员&…
阅读更多...
卷积神经网络（CNN）鲜花的识别

卷积神经网络（CNN）鲜花的识别

文章目录 前期工作1. 设置GPU&#xff08;如果使用的是CPU可以忽略这步&#xff09;我的环境&#xff1a; 2. 导入数据3. 检查数据 二、数据预处理1. 加载数据2. 可视化数据3. 再次检查数据4. 配置数据集 三、构建CNN网络四、编译五、训练模型六、模型评估 前期工作 1. 设置GP…
阅读更多...
串口通信原理及应用

串口通信原理及应用

Content 1. 前言介绍2. 连接方式3. 数据帧格式4. 代码编写 1. 前言介绍 串口通信是一种设备间非常常用的串行接口&#xff0c;以比特位的形式发送或接收数据&#xff0c;由于成本很低&#xff0c;容易使用&#xff0c;工程师经常使用这种方式来调试 MCU。 串口通信应用广泛&a…
阅读更多...
【教3妹学编程-算法题】高访问员工

【教3妹学编程-算法题】高访问员工

2哥 : 3妹&#xff0c;今天周五怎么还下班这么晚啊&#xff1f;这么晚了才回来 3妹&#xff1a;项目快上线了&#xff0c; 最近事情比较多&#xff0c;再累也要干&#xff0c; 撸起袖子加油干&#xff01; 2哥 : 辛苦辛苦&#xff0c; 哎&#xff0c;你看到王自如格力那个采访了…
阅读更多...
叮！您收到了一封来自达坦科技的Hackthon邀请函

叮！您收到了一封来自达坦科技的Hackthon邀请函

DatenLord Hackathon 2023正式启动&#xff01;达坦科技基于其跨云分布式文件系统DatenLord项目&#xff0c;结合AI大模型时代背景&#xff0c;搭建了擂台&#xff0c;在此正式向您发出邀约&#xff01; 本次大赛赛题深刻有趣&#xff0c;奖品丰厚多样&#xff0c;借此机会您不…
阅读更多...
034、test

034、test

之——全纪录 目录 之——全纪录 杂谈 正文 1.下载处理数据 2.数据集概览 3.构建自定义dataset 4.初始化网络 5.训练 杂谈 综合方法试一下。 leaves 1.下载处理数据 从官网下载数据集&#xff1a;Classify Leaves | Kaggle 解压后有一个图片集&#xff0c;一个提交示…
阅读更多...
JavaWeb[总结]

JavaWeb[总结]

文章目录 一、Tomcat1. BS 与 CS 开发介绍1.1 BS 开发1.2 CS 开发 2. 浏览器访问 web 服务过程详解(面试题)2.1 回到前面的 JavaWeb 开发技术栈图2.2 浏览器访问 web 服务器文件的 UML时序图(过程) &#xff01; 二、动态 WEB 开发核心-Servlet1. 为什么会出现 Servlet2. 什么是…
阅读更多...
【C++】模版-初阶

【C++】模版-初阶

目录 泛型编程--模版 函数模版 类模版 泛型编程--模版 函数模版 如何实现一个通用的交换函数呢?void Swap(int& left, int& right){int temp left;left right;right temp;}void Swap(double& left, double& right){double temp left;left right;righ…
阅读更多...
jbase虚拟M层的设计

jbase虚拟M层的设计

对于只是自己产品内部使用的打印程序来说&#xff08;比如打印收费单&#xff0c;打印结算单等&#xff09;&#xff0c;打印逻辑写在js&#xff0c;获取其他层都是没毛病的。但是对于类型检验报告这种打印来说&#xff0c;打印格式控制逻辑写在js层是百分百不行的。因为检验报…
阅读更多...
数据结构-哈希表（C语言）

数据结构-哈希表（C语言）

哈希表的概念 哈希表就是&#xff1a; “将记录的存储位置与它的关键字之间建立一个对应关系&#xff0c;使每个关键字和一个唯一的存储位置对 应。” 哈希表又称&#xff1a;“散列法”、“杂凑法”、“关键字&#xff1a;地址法”。 哈希表思想 基本思想是在关键字和存…
阅读更多...
Express.js 与 Nest.js对比

Express.js 与 Nest.js对比

Express.js 与 Nest.js对比 自从 Node.js 发布以来&#xff0c;Javascript 在后端领域的使用有所增加。由于 Node.js 的使用越来越多&#xff0c;每天都会有新的框架和工具发布。Express 和 Nest 是使用 Node.js 创建后端应用程序的最著名的框架之一&#xff0c;在本文中&…
阅读更多...
数据结构与算法之美学习笔记：20 | 散列表（下）：为什么散列表和链表经常会一起使用？

数据结构与算法之美学习笔记：20 | 散列表（下）：为什么散列表和链表经常会一起使用？

目录 前言LRU 缓存淘汰算法Redis 有序集合Java LinkedHashMap解答开篇 & 内容小结 前言 本节课程思维导图&#xff1a; 今天&#xff0c;我们就来看看&#xff0c;在这几个问题中&#xff0c;散列表和链表都是如何组合起来使用的&#xff0c;以及为什么散列表和链表会经常…
阅读更多...
【代码随想录】算法训练计划21、22

【代码随想录】算法训练计划21、22

day 21 1、530. 二叉搜索树的最小绝对差 题目&#xff1a; 给你一个二叉搜索树的根节点 root &#xff0c;返回 树中任意两不同节点值之间的最小差值 。 差值是一个正数&#xff0c;其数值等于两值之差的绝对值。 思路&#xff1a; 利用了二叉搜索树的中序遍历特性用了双指…
阅读更多...
线性表的概念

线性表的概念

目录 1.什么叫线性表2.区分线性表的题 1.什么叫线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串… 线性表在逻辑上是…
阅读更多...
2.4 矩阵的运算法则

2.4 矩阵的运算法则

矩阵是数字或 “元素” 的矩形阵列。当矩阵 A A A 有 m m m 行 n n n 列&#xff0c;则是一个 m n m\times n mn 的矩阵。如果矩阵的形状相同&#xff0c;则它们可以相加。矩阵也可以乘上任意常数 c c c。以下是 A B AB AB 和 2 A 2A 2A 的例子&#xff0c;它们都是 …
阅读更多...
JSplacement丨随机生成置换贴图

JSplacement丨随机生成置换贴图

界面很简单&#xff0c;虽然是英文&#xff0c;但基本也能看懂&#xff0c;参数调一调&#xff0c;随机生成不重复的8K高清图片。 这种图片可能对普通人感觉很奇怪&#xff0c;有什么用呢&#xff1f;会C4D建模渲染的同学应该会明白&#xff0c;特别是建一些科技类的场景背景&a…
阅读更多...
短期经济波动：均衡国民收入决定理论(三)

短期经济波动：均衡国民收入决定理论(三)

短期经济波动&#xff1a;国民收入决定理论(三) 文章目录 短期经济波动&#xff1a;国民收入决定理论(三)[toc]1 总需求曲线及其变动1.1 总需求曲线含义1.2 总需求曲线推导1.2.1 代数推导1.2.2 几何推导 1.3 AD曲线及其变动1.3.1 扩张性财政政策1.3.2 扩张性货币政策 2 总供给曲…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023