leetcode栈和队列的相关题、有效的括号、用队列实现栈、用栈实现队列、设计循环队列等介绍

news2024/9/20 9:36:00

文章目录

  • 前言
  • 一、有效的括号
  • 二、用队列实现栈
  • 三、 用栈实现队列
  • 四、设计循环队列
  • 总结

前言

leetcode栈和队列的相关题、有效的括号、用队列实现栈、用栈实现队列、设计循环队列等介绍

一、有效的括号

leetcode有效的括号
在这里插入图片描述


// 动态增长的栈
typedef char STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;


// 初始化栈
void STInit(ST* ps);

// 销毁栈
void STDestroy(ST* ps);

// 插入
void STPush(ST* ps, STDataType x);

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

// 检查是否为空
bool STEmpty(ST* ps);

// 获取栈顶元素
STDataType STTop(ST* ps);

//获取有效元素的个数
int STSize(ST* ps);


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

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("STInit malloc");
		return;
	}

	ps->top = 0; // top指的是栈顶元素的下一个位置
	//ps->top = -1; // top 指的是栈顶元素
	ps->capacity = 4;
}



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

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

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



// 入栈
void STPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("STPush relloc");
			return;
		}

		ps->a = tmp;
		ps->capacity *= 2;
		
	}

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


// 出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

	ps->top--;
}


// 检查是否为空
bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}



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


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



// 获取有效元素的个数
int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}


bool isValid(char* s) {
    
    ST st;
    STInit(&st);

    while(*s)
    {
        if(*s == '(' || *s == '[' || *s == '{')
        {
            STPush(&st, *s);
        }
        else
        {
            if(STEmpty(&st))
            {
                STDestroy(&st);
                return false;
            }

            char top = STTop(&st);
            STPop(&st);

            if((*s == ')' && top != '(')
            || (*s == ']' && top != '[')
            || (*s == '}' && top != '{'))
            {
                STDestroy(&st);
                return false;
            }
        }
        s++;
    }

    bool ret = STEmpty(&st);

    STDestroy(&st);

    return ret;
}

二、用队列实现栈

leetcode用队列实现栈

在这里插入图片描述

typedef int QDataType;

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



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


// 初始化队列
void QInit(Queue* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;

}


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

	QNode* cur = pq->head;

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


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

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("QPush()::malloc()");
		return;
	}
	newnode->next = NULL;
	newnode->data = x;

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

// 出队列
void QPop(Queue* pq)
{
	assert(pq);
	assert(pq->head != NULL);

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

		free(cur);
		cur = NULL;
	}
	pq->size--;
	
}



// 获取队列元素个数
int QSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}


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

	return (pq->head == NULL && pq->tail == NULL);
}


// 找到队列的头元素
QDataType QFront(Queue* pq)
{
	assert(pq);
	assert(!QEmpty(pq));

	return (pq->head->data);
}


// 找到队列的尾元素
QDataType QBack(Queue* pq)
{
	assert(pq);
	assert(!QEmpty(pq));

	return (pq->tail->data);
}


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


MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    if(pst == NULL)
    {
        perror("myStackCreate malloc");
        return NULL;
    }

    QInit(&pst->q1);
    QInit(&pst->q2);

    return pst;
}

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

int myStackPop(MyStack* obj) {
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;

    if(!QEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }

    while(QSize(nonempty) > 1)
    {
        QPush(empty, QFront(nonempty));
        QPop(nonempty);
    }

    int top = QFront(nonempty);
    QPop(nonempty);
    return top;
}

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

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

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

    obj = NULL;
}

/**
 * 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);
*/

三、 用栈实现队列

leetcode用栈实现队列

在这里插入图片描述

// 动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

// 初始化栈
void STInit(ST* ps);

// 销毁栈
void STDestroy(ST* ps);

// 插入
void STPush(ST* ps, STDataType x);

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

// 检查是否为空
bool STEmpty(ST* ps);

// 获取栈顶元素
STDataType STTop(ST* ps);

//获取有效元素的个数
int STSize(ST* ps);

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

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("STInit malloc");
		return;
	}

	ps->top = 0; // top指的是栈顶元素的下一个位置
	//ps->top = -1; // top 指的是栈顶元素
	ps->capacity = 4;
}



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

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

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



// 入栈
void STPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("STPush relloc");
			return;
		}

		ps->a = tmp;
		ps->capacity *= 2;
		
	}

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


// 出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

	ps->top--;
}


// 检查是否为空
bool STEmpty(ST* ps)
{
	assert(ps);

	return (ps->top == 0);
}



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


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



// 获取有效元素的个数
int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}


typedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* tmp = (MyQueue*)malloc(sizeof(MyQueue));
    if(tmp == NULL)
    {
        perror("myQueueCreate malloc");
        return NULL;
    }

    STInit(&tmp->pushst);
    STInit(&tmp->popst);

    return tmp;
}

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

int myQueuePop(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst, STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }

    int front = STTop(&obj->popst);

    STPop(&obj->popst);
    return front;
}

int myQueuePeek(MyQueue* obj) {
        if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst, STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }

    int front = STTop(&obj->popst);

    return front;
}

bool myQueueEmpty(MyQueue* obj) {
    return (STEmpty(&obj->pushst) && STEmpty(&obj->popst));
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);

    free(obj);
    obj = NULL;
}

/**
 * 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);
*/

四、设计循环队列

leetcode设计循环队列

在这里插入图片描述


typedef struct {
    int* a;
    int Front;
    int Rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* tmp = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));

    tmp->a = (int*)malloc(sizeof(int) * (k+1));
    tmp->Front = tmp->Rear = 0;
    tmp->k = k;

    return tmp;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return (obj->Front == obj->Rear);
}

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

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 = obj->Front % (obj->k + 1);
    obj->Front++;
    return true;
    
}

int myCircularQueueFront(MyCircularQueue* obj) {
    // 判断队列为空 返回 -1
    if(myCircularQueueIsEmpty(obj))
    {
        return - 1;
    }

    return obj->a[obj->Front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    // 判断队列为空 返回 -1
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }

    return obj->a[(obj->Rear-1 + (obj->k + 1)) % (obj->k + 1)];
}



void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a = NULL;
    obj->Front = obj->Rear = 0;
    obj->k = 0;
    free(obj);
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

总结

leetcode栈和队列的相关题、有效的括号、用队列实现栈、用栈实现队列、设计循环队列等介绍

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

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

相关文章

针对上两篇微信同声传译语音播报功能，又出现了坑

针对上两篇微信同声传译语音播报功能，又出现了坑

我又双叒叕来了，自己写的bug，跪着也要改完，我是真的服了 首先，我们来说说是什么问题吧 上一篇文章的这张图还记得吧，不记得的，我在下面贴出来了； 我们在长度大于300的时候，根据句号…
阅读更多...
嵌入式学习记录5.27(c++基础1）

嵌入式学习记录5.27(c++基础1）

目录 一.C和C的区别 二.输入输出流类 2.1输出cout 2.2输入cin 三.命名空间 2.1使用命名空间中的标识符 2.2命名空间中声明函数 2.3命名冲突问题 2.4匿名空间 2.5命名空间添加，嵌套，重命名 四.字符串的使用 4.1string类 4.2C风格和C风格字符串…
阅读更多...
出生率下降 幼儿园如何面对困境创新转型

出生率下降 幼儿园如何面对困境创新转型

从2023年开始，全国幼儿园生存发展问题成为教育界焦点，民办幼儿园更为焦虑满满。当今年轻人对待婚姻和生育的观念，的确让上一辈人始料未及。那么，是否幼儿园再也不可能回到巅峰时期了？是否很多幼儿教育者将无用武之地呢…
阅读更多...
只要尝试一次API正向工程，你就会无可救药的爱上她！

只要尝试一次API正向工程，你就会无可救药的爱上她！

何为正向，何为反向？ 举个例子：在数据库的设计里面这个概念可能被大量涉猎；古早先是 DBA设计好表以及表之间的关系(一对多，多对一，多对多...)；然后应用是通过ORM 映射数据库表到业务内领域对象&a…
阅读更多...
[猫头虎分享21天微信小程序基础入门教程] 第17天：小程序的用户授权与安全

[猫头虎分享21天微信小程序基础入门教程] 第17天：小程序的用户授权与安全

[猫头虎分享21天微信小程序基础入门教程] 第17天：小程序的用户授权与安全 第17天：小程序的用户授权与安全 🔒 自我介绍 大家好，我是猫头虎，一名全栈软件工程师。今天我们继续微信小程序的学习，重点了解如…
阅读更多...
OrangePi AIpro 性能测试以及使用体验

OrangePi AIpro 性能测试以及使用体验

OrangePi AIpro 性能测试以及使用体验 1. 介绍 OrangePi AIpro(8T)采用昇腾AI技术路线。 具体为4核64位处理器AI处理器，集成图形处理器，支持8TOPS AI算力拥有8GB/16GB LPDDR4X，可以外接32GB/64GB/128GB/256GB eMMC模块，支持双4…
阅读更多...
超详细避坑指南！OrangpiAIPro转换部署模型全流程！

超详细避坑指南！OrangpiAIPro转换部署模型全流程！

目录 OrangepiPro初体验 前述： 一、硬件准备 二、安装CANN工具链（虚拟机） 三、配置模型转换环境（虚拟机） 1.安装miniconda 。 2.创建环境。 3.安装依赖包 四、转换模型 1. 查看设备号（开发板&…
阅读更多...
Linux服务器安装anaconda、配置pytorch环境

Linux服务器安装anaconda、配置pytorch环境

Linux服务器安装anaconda并配置pytorch环境 Linux服务器安装anaconda下载anaconda安装anaconda验证是否安装成功注意默认python版本 配置pytorch环境新建虚拟环境安装pytorch Linux服务器安装anaconda 下载anaconda 首先进入anaconda网站，根据自己的需要选择一个版…
阅读更多...
LLM中的RoPE位置编码代码解析与RoPE的性质分析（一）

LLM中的RoPE位置编码代码解析与RoPE的性质分析（一）

本博客需要对位置编码有一定了解，但不熟悉代码实现的老哥看。 正弦位置编码（sinusoidal） 在介绍RoPE之前，先回顾一下正弦位置编码。 数学表达 P E ( p o s , 2 i ) s i n ( p o s 1000 0 2 i / d m o d e l ) PE(pos, 2i) sin…
阅读更多...
5.27作业

5.27作业

定义自己的命名空间my_sapce&#xff0c;在my_sapce中定义string类型的变量s1&#xff0c;再定义一个函数完成对字符串的逆置。 #include <iostream>using namespace std; namespace my_space {string s1;string reverse1(string s1);} using namespace my_space; int m…
阅读更多...
Web（数字媒体）期末作业

Web（数字媒体）期末作业

一.前言 1.本资源为类似于打飞机的网页游戏 2.链接如下&#xff1a;【免费】前端web或者数字媒体的期末作业&#xff08;类似于打飞机的2D网页小游戏&#xff09;资源-CSDN文库 二.介绍文档
阅读更多...
HR人才测评，哪些岗位需要测评想象力？

HR人才测评，哪些岗位需要测评想象力？

什么是想象力&#xff1f; 想象力是指&#xff0c;人们通过在已有物质的基础上&#xff0c;通过大脑想象、加工、创造出新事物的能力&#xff0c;举一个非常简单的例子&#xff0c;在提到鸟这种生活的时候&#xff0c;大家会联想到各种各样不同鸟的品种。 哪些岗位需要测评…
阅读更多...
喜讯 | 聚铭网络入选2024安在新榜网络安全产品“大众点评”百强榜及全景图

喜讯 | 聚铭网络入选2024安在新榜网络安全产品“大众点评”百强榜及全景图

近日&#xff0c;安在新榜发布了备受期待的《2024中国网络安全产品用户调查报告》。在这份权威报告中&#xff0c;聚铭网络凭借先进的技术、优秀的产品和专业的配套服务&#xff0c;成功入选《2024安在新榜网络安全产品“大众点评”百强榜》。 报告通过对全国企业用户进行专项调…
阅读更多...
海外仓erp系统是什么？和海外仓管理系统一样吗？

海外仓erp系统是什么？和海外仓管理系统一样吗？

为了满足海外仓全球化发展的大趋势&#xff0c;同时提升海外仓运转的效率&#xff0c;一套好用&#xff0c;性价比高的海外仓管理系统还是非常重要的。 不过很多海外仓企业其实不太分得清erp系统和海外仓管理系统的差异&#xff0c;今天我们就来系统的聊一下&#xff0c;方便大…
阅读更多...
React useState修改对象

React useState修改对象

在 React 中&#xff0c;useState 是一个 Hook&#xff0c;它可以让函数组件拥有状态。当想要改变一个对象类型的状态时&#xff0c;我们需要使用展开运算符&#xff08;...&#xff09;或者 Object.assign 来确保状态是正确地更新。 以下是一个使用 useState 来更新对象的例子…
阅读更多...
windows下nvm的安装及使用

windows下nvm的安装及使用

目录 一、下载二、安装三、使用 一、下载 下载链接&#xff1a;https://github.com/coreybutler/nvm-windows/releases 二、安装 双击 nvm-setup.exe&#xff0c;按提示一步步安装。 三、使用 # 查看已安装的版本信息 nvm list&#xff08;可简写为&#xff1a;nvm ls&am…
阅读更多...
计算机视觉中-语义分割

计算机视觉中-语义分割

语义分割 语义分割是计算机视觉中的一个关键技术&#xff0c;它涉及对图像中的每个像素进行类别划分&#xff0c;从而识别出图像中的不同物体或区域。具体来说&#xff0c;语义分割就是按照“语义”给图像上目标类别中的每一点打上一个标签&#xff0c;使得不同种类的东西在图像…
阅读更多...
【RSGIS数据资源】中国多时期土地利用遥感监测数据集（CNLUCC）

【RSGIS数据资源】中国多时期土地利用遥感监测数据集（CNLUCC）

文章目录 数据基本信息摘要数据说明数据引用方式 数据基本信息 数据时间&#xff1a; 多时期(1970年代末期以来11期) 空间位置&#xff1a; 中国 数据格式&#xff1a; 矢量与栅格 空间分辨率&#xff1a; 30m 主题分类&#xff1a; 中国土地利用遥感监测数据 DOI标识&#xf…
阅读更多...
Android Gradle plugin 版本和Gradle 版本

Android Gradle plugin 版本和Gradle 版本

1.当看到这两个版本时&#xff0c;确实有点迷糊。但是他们是独立的&#xff0c;没有太大关联。 就是说在Android studio中看到的两个版本信息&#xff0c;并无太大关联&#xff0c;是相互独立的。Gradle插件版本决定了你的项目是如何构建的&#xff0c;而Gradle版本是执行构建…
阅读更多...
UML-系统架构师（二）

UML-系统架构师（二）

1、UML&#xff08;Unified Modeling Language&#xff09;是面向对象设计的建设工具&#xff0c;独立于任何具体程序设计语言&#xff0c;以下&#xff08;&#xff09;不属于UML中的模型。 A用例图 B协作图 C活动图 DPAD图 解析&#xff1a; UML一共14种图 结构图&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023