【数据结构】栈和队列-- OJ

news2024/11/27 17:56:13

目录

一 用队列实现栈

二 用栈实现队列 

三 设计循环队列 

四 有效的括号

一 用队列实现栈

225. 用队列实现栈 - 力扣（LeetCode）

 

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

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


void QueueInit(Que* pq)
{
	assert(pq);

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

void QueueDestroy(Que* 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 QueuePush(Que* pq, QDataType x)
{
	assert(pq);

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

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

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

	pq->size++;
}

bool QueueEmpty(Que* pq)
{
	assert(pq);
	return pq->head == NULL;
}

void QueuePop(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	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(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QDataType QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}


int QueueSize(Que* pq)
{
	assert(pq);

	return pq->size;
}

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


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

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

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

	int top = QueueFront(nonempty);
	QueuePop(nonempty);
	return top;
}

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);
}

 

二 用栈实现队列 

232. 用栈实现队列 - 力扣（LeetCode）

 

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

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

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

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

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

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

STDataType STTop(ST* ps)
{
    assert(ps);
    assert(ps->top > 0);
    return ps->a[ps->top - 1];
}

int STSize(ST* ps)
{
    assert(ps);
    return ps->top;
}

bool STEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}


typedef struct {
    ST StackPush;
    ST StackPop;

} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* pqueue = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&pqueue->StackPush);
    STInit(&pqueue->StackPop);
    return pqueue;
}

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

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

}


int myQueuePop(MyQueue* obj) {
    int front = myQueuePeek(obj);
    STPop(&obj->StackPop);
    return front;
}


bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->StackPush) && STEmpty(&obj->StackPop);
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->StackPush);
    STDestroy(&obj->StackPop);
    free(obj);
}

三 设计循环队列 

622. 设计循环队列 - 力扣（LeetCode）

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


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int) * (k + 1));//多开一个空间
    obj->front = obj->rear = 0;
    obj->k = k;
    return obj;
}

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->k + 1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    obj->front %= (obj->k + 1);
    return true;
}

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

}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else {
        return obj->a[(obj->rear + obj->k) % (obj->k + 1)];
    }

}


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

 

 

四 有效的括号

20. 有效的括号 - 力扣（LeetCode）

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

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

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

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

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

STDataType STTop(ST* ps)
{
    assert(ps);
    assert(ps->top > 0);
    return ps->a[ps->top - 1];
}

int STSize(ST* ps)
{
    assert(ps);
    return ps->top;
}

bool STEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}


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 topval = STTop(&st);
            STPop(&st);
            if ((*s == ']' && topval != '[') || (*s == ')' && topval != '(') || (*s == '}' && topval != '{'))
            {
                STDestroy(&st);
                return false;
            }
        }
        s++;
    }

    bool ret = STEmpty(&st);
    STDestroy(&st);
    return ret;
}

 

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

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

相关文章

数据结构 | (三) Stack

数据结构 | (三) Stack

栈 ：一种特殊的线性表，其 只允许在固定的一端进行插入和删除元素操作 。 进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO （ Last In First Out ）的原则。 压栈：栈…
阅读更多...
c#学习系列相关之多线程（三）----invoke和begininvoke

c#学习系列相关之多线程（三）----invoke和begininvoke

一、invoke和BeginInvoke的作用 invoke和begininvoke方法的初衷是为了解决在某个非某个控件创建的线程中刷新该控件可能会引发异常的问题。说的可能比较拗口，举个例子：主线程中存在一个文本控件，在一个子线程中要改变该文本的值，此…
阅读更多...
（四）列表、元组、字典和集合

（四）列表、元组、字典和集合

Python列表（list）、元组（tuple）、字典（dict）和集合（set）详解 Python 序列（Sequence）是指按特定顺序依次排列的一组数据，它们可以占用一块连续的内…
阅读更多...
【C/C++】关于vector迭代器失效问题

【C/C++】关于vector迭代器失效问题

​👻内容专栏： C/C编程 🐨本文概括： vector迭代器失效问题 🐼本文作者： 阿四啊 🐸发布时间：2023.10.8 迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就…
阅读更多...
C++变量默认初始化

C++变量默认初始化

初始化不是赋值，初始化是指创建变量时赋予一个初始值，赋值是指将变量的当前值擦除，赋予新值。 如果定义变量时没有初始化，则变量会被系统默认初始化。“默认值”取决于变量的：类型位置 startmindmap * C变量默认初始…
阅读更多...
邮件群发工具哪个好

邮件群发工具哪个好

邮件群发是一种通过电子邮件向多个收件人发送邮件的方式。同时，邮件群发也是一种低成本、高回报的营销手段。因此邮件群发被广泛应用于各种营销活动中，例如活动邀请、新品上线、产品促销等等。而群发邮件最有效的方式就是借助邮件群发工具，而…
阅读更多...
常用排序算法详解

常用排序算法详解

1.冒泡排序原理示例代码实现 2.快速排序原理示例代码实现 3.插入排序原理示例代码实现 4.希尔排序原理示例代码实现 5.选择排序原理示例代码实现 6.堆排序原理示例代码实现 7.归并排序原理示例代码实现 本文讲述了常见的排序算法的执行过程，有详细实现过程举例 1.冒…
阅读更多...
arm 点灯实验代码以及现象

arm 点灯实验代码以及现象

.text .global _start _start: 1.设置GPIOE寄存器的时钟使能 RCC_MP_AHB4ENSETR[4]->1 0x50000a28 LDR R0,0x50000A28 LDR R1,[R0] ORR R1,R1,#(0x1<<4) 第4位置1 STR R1,[R0] 1.设置GPIOF寄存器的时钟使能 RCC_MP_AHB4ENSETR[4]->1 0x50000a28 LDR R…
阅读更多...
自动定时删除磁盘文件的脚本（从文件日期最早的开始删）

自动定时删除磁盘文件的脚本（从文件日期最早的开始删）

#!/bin/bash# 指定的挂载点 MOUNTPOINT"/media/vm/MyDisk512GB"# 设置磁盘大小的限制 (例如&#xff1a;800G) LIMIT$((800 * 1024 * 1024)) # 单位是KB# 获取挂载点的已使用空间 USED_SPACE$(df -kP "$MOUNTPOINT" | tail -1 | awk {print $3})echo &quo…
阅读更多...
强化学习------Qlearning算法

强化学习------Qlearning算法

简介 Q learning 算法是一种value-based的强化学习算法&#xff0c;Q是quality的缩写&#xff0c;Q函数 Q(state&#xff0c;action)表示在状态state下执行动作action的quality&#xff0c; 也就是能获得的Q value是多少。算法的目标是最大化Q值&#xff0c;通过在状态state下…
阅读更多...
day58：ARMday5，GPIO流水灯实验

day58：ARMday5，GPIO流水灯实验

汇编指令&#xff1a; .text .global _start _start: 1.设置GPIOE GPIOF寄存器的时钟使能 RCC_MP_AHB4ENSETR[5:4]->1 0x50000a28 LDR R0,0x50000a28 LDR R1,[R0] ORR R1,R1,#(0x3<<4) STR R1,[R0]2.设置PE10、PF10、PE8管脚为输出模式&#xff0c;GPIOE_MODER[21…
阅读更多...
【gcc】RtpTransportControllerSend学习笔记 1

【gcc】RtpTransportControllerSend学习笔记 1

本文是woder大神 的文章的学习笔记。主要是大神文章： webrtc源码分析(8)-拥塞控制(上)-码率预估 的学习笔记。大神的webrtc源码分析(8)-拥塞控制(上)-码率预估 详尽而具体，堪称神作。因为直接看大神的文章，自己啥也没记住，所以同时跟着看代码。跟着大神走一遍，不求甚解，…
阅读更多...
SpringCloud学习笔记-注册微服务到Eureka注册中心

SpringCloud学习笔记-注册微服务到Eureka注册中心

目录 1.在该Module的pom文件中引入eureka依赖2.在该module的src/main/resources/application.yml配置文件3.启动对应的微服务4.查看微服务是否启动成功 假如我有一个微服务名字叫user-service,我需要把它注册到Eureka注册中心,则具体步骤如下: 1.在该Module的pom文件中引入eure…
阅读更多...
MQ - 38 Serverless : 基于Serverless架构实现流式数据处理

MQ - 38 Serverless : 基于Serverless架构实现流式数据处理

文章目录 导图Pre概述典型的数据流场景什么是 ServerlessServerless 的定义Serverless Function如何基于 Serverless 实现数据处理数据处理流程底层架构和技术原理两种方案的优劣势对比业务案例和场景分析日志清洗场景事件流处理其他case总结导图
阅读更多...
geecg-uniapp 源码下载运行 修改端口号 修改tabBar 修改展示数据

geecg-uniapp 源码下载运行 修改端口号 修改tabBar 修改展示数据

APP体验&#xff1a; http://jeecg.com/appIndex技术官网&#xff1a; http://www.jeecg.com安装文档&#xff1a; 快速开始 JeecgBoot 开发文档 看云视频教程&#xff1a; 零基础入门视频官方支持&#xff1a; http://jeecg.com/doc/help 一&#xff0c;下载安装 源码下载…
阅读更多...
【力扣面试题】URL化

【力扣面试题】URL化

&#x1f451;专栏内容&#xff1a;力扣刷题⛪个人主页&#xff1a;子夜的星的主页&#x1f495;座右铭&#xff1a;前路未远&#xff0c;步履不停 目录 一、题目描述二、题目分析1、使用String内部方法2、使用StringBuilder 一、题目描述 题目链接&#xff1a;URL化 编写一种…
阅读更多...
【软考】5.2 传输介质/通信方式/IP地址/子网划分

【软考】5.2 传输介质/通信方式/IP地址/子网划分

《传输介质》 双绞线&#xff1a;网线&#xff1b;传输距离在100m以内 无屏蔽双绞线&#xff1a;UTP&#xff1b;可靠性相对较低屏蔽双绞线&#xff1a;STP&#xff1b;屏蔽怕干扰&#xff1b;可靠性相对较高&#xff1b;一般用于对传输可靠性要求很高的场合 网线&#xff1a…
阅读更多...
【Java 进阶篇】HTML块级元素详解

【Java 进阶篇】HTML块级元素详解

HTML&#xff08;Hypertext Markup Language&#xff09;是用于创建网页的标记语言。在HTML中&#xff0c;元素被分为块级元素和内联元素两种主要类型。块级元素通常用于构建网页的结构&#xff0c;而内联元素则嵌套在块级元素内&#xff0c;用于添加文本和其他内容。本文将重点…
阅读更多...
卷积层与池化层输出的尺寸的计算公式详解

卷积层与池化层输出的尺寸的计算公式详解

用文字简单表述如下 卷积后尺寸计算公式&#xff1a; (图像尺寸-卷积核尺寸 2*填充值)/步长1 池化后尺寸计算公式&#xff1a; (图像尺寸-池化窗尺寸 2*填充值)/步长1 一、卷积中的相关函数的参数定义如下&#xff1a; in_channels(int) – 输入信号的通道 out_channels(int)…
阅读更多...
ubuntu2204配置仓库为阿里源

ubuntu2204配置仓库为阿里源

官网上支持到2004&#xff0c;2204需要手动更改一下 deb https://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse deb-src https://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiversedeb https://mirrors.aliyun.com/ubuntu/ jam…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023