【栈和队列】算法题 ---- 力扣

news2024/11/16 0:01:51

        通过前面栈和队列的学习，现在来看这些算法题目

一、有效的括号

        本题让判断括号是否有效

第一眼看可能没一点思路，但仔细分析一下；

        我们学习过栈数据结构，知道栈先进后出的原则，那我们就可以使用啊；把题目的左括号存储起来，让右括号跟左括号一一比较。

思路：

        遍历字符串，遇到左括号就括号入栈，遇到右括号就与栈顶数据进行对比，如果配对就继续；如果不配对，就返回false

画图分析：

  现在有这样的括号字符串

        遍历字符串，第一个是  {  左括号，就入栈

        ps接着遍历， [  依然是左括号，入栈

        ps接着遍历，  (  还是左括号，入栈

        ps接着遍历，  )  是右括号，与栈顶数据进行比较，括号匹配，出栈

        ps接着遍历，  ]  是右括号，与栈顶数据比较，括号匹配，出栈

        ps接着遍历，  }  是右括号，与栈顶数据进行比较，括号匹配，出栈

        ps遍历完字符串，再判断栈是否为空？如果为空，就代表所以括号都匹配了；如果栈不为空，括号就不匹配。

        此外，再遍历过程中，有依次括号不匹配就要直接返回false

力扣题代码如下：

typedef char SType;
typedef struct Stack {
    SType* arr;
    int size; // 栈顶
    int num;  // 空间大小
} Stack;

// 初始化
void STInit(Stack* ps) {
    assert(ps);
    ps->arr = NULL;
    ps->size = ps->num = 0;
}
// 判断栈是否为空
bool STEmpty(Stack* ps) {
    assert(ps);
    return ps->size == 0;
}
// 入栈
void STPush(Stack* ps, SType x) {
    assert(ps);
    // 判断空间大小是否足够
    if (ps->num <= ps->size) {
        int newnum = (ps->num == 0) ? 4 : 2 * ps->num;
        SType* tmp = (SType*)realloc(ps->arr, newnum * sizeof(Stack));
        if (tmp == NULL) {
            perror("realloc filed");
            exit(1);
        }
        ps->arr = tmp;
        ps->num = newnum;
    }
    ps->arr[ps->size++] = x;
}
// 出栈
void STPop(Stack* ps) {
    assert(ps);           // 不能传NULL
    assert(!STEmpty(ps)); // 栈不能为空
    ps->size--;
}
// 取栈顶数据
SType STtop(Stack* ps) {
    assert(ps);           // 不能传NULL
    assert(!STEmpty(ps)); // 栈不能为空
    return ps->arr[ps->size - 1];
}
// 获取栈中数据个数
int STSize(Stack* ps) {
    assert(ps);
    return ps->size;
}
// 栈的销毁
void STDesTroy(Stack* ps) {
    assert(ps);
    if (ps->arr)
        free(ps->arr);
    ps->arr = NULL;
    ps->size = ps->num = 0;
}

bool isValid(char* s) {
    Stack arr;
    // 初始化
    STInit(&arr);
    char* ps = s;
    while (*ps != '\0') {
        if (*ps == '(' || *ps == '[' || *ps == '{') {
            // 入栈
            STPush(&arr, *ps);
        } else {
            // 取栈顶数据
            if (STEmpty(&arr)) {
                return false;
            }
            char ch = STtop(&arr);
            if ((ch == '(' && *ps == ')') || (ch == '[' && *ps == ']') ||
                (ch == '{' && *ps == '}')) {
                STPop(&arr);
            } else {
                return false;
            }
        }
        ps++;
    }
    if (STEmpty(&arr)) // 栈为空
    {
        return true;
    }
    return false;
}

二、用队列实现栈

        使用队列来实现栈，我们直到，队列是先进先出，而栈是先进后出。这里我们需要用两个队列来实现栈的相关操作

思路：

        保证两个队列中有一个为空，再两个队列之间来回导入导出数据。

        入栈：往不为空的队列里面插入数据

        出栈：找到不为空的队列，将size-1个数据导入到另一个队列，最后剩余的一个数据，就是要出栈的数据

        取栈顶元素：找到不为空的队列，取队尾元素即可

假设依次插入了1，2，3三个数据，现在要出栈

        将q1中数据size-1（2个）导入到q2中。

        现在q1当中剩余的数据就是要出栈的数据（即栈顶）。这样就满足了栈先进先出的特点。

力扣题代码如下：

typedef int QType;
typedef struct QueueNode // 队列节结构
{
    QType data;
    struct QueueNode* next;
} QueueNode;
typedef struct Queue // 队列结构
{
    int size;         // 队列中的数据个数
    QueueNode* phead; // 队头
    QueueNode* ptial; // 队尾
} Queue;

// 初始化
void QueueInit(Queue* pq) {
    assert(pq);
    pq->phead = pq->ptial = NULL;
    pq->size = 0;
}
// 判断队列是否为空
bool QueueEmpty(Queue* pq) {
    assert(pq);
    return pq->size == 0;
}
// 入队列--从队尾插入数据
void QueuePush(Queue* pq, QType x) {
    assert(pq);
    QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
    newnode->data = x;
    newnode->next = NULL;
    if (QueueEmpty(pq)) // 队列为空
    {
        pq->phead = pq->ptial = newnode;
    } else { // 队列不为空
        pq->ptial->next = newnode;
        pq->ptial = newnode;
    }
    pq->size++;
}
// 出队列--从对头删除数据
void QueuePop(Queue* pq) {
    assert(pq);              // 不能传NULL
    //assert(!QueueEmpty(pq)); // 队列不能为空
    QueueNode* del = pq->phead;
    pq->phead = pq->phead->next;
    if (pq->size == 1) // 队列只有一个节点
    {
        pq->ptial = NULL;
    }
    pq->size--;
    free(del);
    del = NULL;
}
// 取队头数据
QType QueueFront(Queue* pq) {
    assert(pq);              // 不能传NULL
    //assert(!QueueEmpty(pq)); // 队列不能为空
    return pq->phead->data;
}
// 取队尾数据
QType QueueBack(Queue* pq) {
    assert(pq);              // 不能传NULL
    //assert(!QueueEmpty(pq)); // 队列不能为空
    return pq->ptial->data;
}
// 获取队列数据个数
int QueueSize(Queue* pq) {
    assert(pq); // 不能传NULL
    return pq->size;
}
// 销毁队列
void QueueDesTroy(Queue* pq) {
    assert(pq);              // 不能传NULL
    //assert(!QueueEmpty(pq)); // 队列不能为空
    QueueNode* pcur = pq->phead;
    while (pcur) {
        QueueNode* del = pcur;
        pcur = pcur->next;
        free(del);
        del = NULL;
    }
    pq->phead = pq->ptial = NULL;
    pq->size = 0;
}

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

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

void myStackPush(MyStack* obj, int x) {
    // 往不为空的队列中插入数据
    if (QueueEmpty(&obj->q1)) {
        QueuePush(&obj->q2, x);
    } else {
        QueuePush(&obj->q1, x);
    }
}

int myStackPop(MyStack* obj) {
    // 先找到不为空的队列
    Queue* empq = &obj->q1;
    Queue* noneq = &obj->q2;
    if (!(QueueEmpty(&obj->q1))) // 如果q1不为空
    {
        empq = &obj->q2;
        noneq = &obj->q1;
    }
    //empq --  空队列
    //noneq --  非空队列
    while(QueueSize(noneq) > 1) {
        // 将noneq队列的数据导入到empq中去
        QueuePush(empq, QueueFront(noneq));
        QueuePop(noneq);
    }
    int ret = QueueFront(noneq);
    QueuePop(noneq);
    return ret;
}

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) {
    free(obj);
    obj = NULL;
}

三、用栈实现队列

        上一个题让我们用队列来实现栈，这个用两个栈来实现队列。

定义两个栈

思路：

        往PushST中插入数据，再将数据导入到PopST中，出栈即可；

        入队列：往PushST中插入数据

        出队列：判断栈PopST是否为空？如果PopST栈为空，就将栈PushST中数据导入到栈PopST中去，再让栈PopST出栈操作；如果不为空，直接让栈PopST出栈操作即可。

        取队头数据：和出队列操作一样，只是不需要出栈操作，只取数据

分析：

        假设依次插入了1，2，3三个数据，现在出栈一次，再插入一个数据4，最后取队头数据，依次出栈。

        出栈一次，PopST为空，就将PushST中数据导入到PopST中去。

依次导入

        出栈；

再插入数据4

取队头数据：

最后依次出队列

现在，PopST栈为空，就要先将PushST中数据先导入到PopST中。

再出队列

力扣题代码如下：

typedef int SType;
typedef struct Stack
{
	SType* arr;
	int size;  //栈顶
	int num;   //空间大小
}Stack;
//初始化
void STInit(Stack* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->size = ps->num = 0;
}
//判断栈是否为空
bool STEmpty(Stack* ps)
{
	assert(ps);
	return ps->size == 0;
}
//入栈
void STPush(Stack* ps, SType x)
{
	assert(ps);
	//判断空间大小是否足够
	if (ps->num <= ps->size)
	{
		int newnum = (ps->num == 0) ? 4 : ps->num * 2;
		SType* tmp = (SType*)realloc(ps->arr, newnum * sizeof(Stack));
		if (tmp == NULL)
		{
			perror("realloc filed");
			exit(1);
		}
		ps->arr = tmp;
		ps->num = newnum;
	}
	ps->arr[ps->size++] = x;
}
//出栈
void STPop(Stack* ps)
{
	assert(ps); //不能传NULL
	assert(!STEmpty(ps));  //栈不能为空
	ps->size--;
}
//取栈顶数据
SType STtop(Stack* ps)
{
	return ps->arr[ps->size - 1];
}
//获取栈中数据个数
int STSize(Stack* ps)
{
	assert(ps);
	return ps->size;
}
//栈的销毁
void STDesTroy(Stack* ps)
{
	assert(ps);
	if (ps->arr)
		free(ps->arr);
	ps->arr = NULL;
	ps->size = ps->num = 0;
}


typedef struct {
    Stack s1;
    Stack s2;
} MyQueue;

//初始化
MyQueue* myQueueCreate() {
    MyQueue* Queue=(MyQueue*)malloc(sizeof(MyQueue));
    STInit(&Queue->s1);
    STInit(&Queue->s2);
    return Queue;
}
//插入数据
void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    STPush(&obj->s1, x);
}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    if(STEmpty(&obj->s2))
    {
        //把s1中数据导入到s2
        while(!STEmpty(&obj->s1))
        {
            STPush(&obj->s2,STtop(&obj->s1));
            STPop(&obj->s1);
        }
    }
    int ret=STtop(&obj->s2);
    STPop(&obj->s2);
    return ret;
}

int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->s2))
    {
        //把s1中数据导入到s2
        while(!STEmpty(&obj->s1))
        {
            STPush(&obj->s2,STtop(&obj->s1));
            STPop(&obj->s1);
        }
    }
    return STtop(&obj->s2);
}

bool myQueueEmpty(MyQueue* obj) {
    return (STEmpty(&obj->s1)) && (STEmpty(&obj->s2));
}

void myQueueFree(MyQueue* obj) {
    if(obj)
        free(obj);
    obj=NULL;
}

四、设计循环队列

        设计循环队列，这里使用数组来设计

这里会设计到的一些问题：

        插入数据，如何判断空间是否满了？       

这里多申请一个空间，便于判断空间是否满了

        删除数据，如何去删？

这里，删除front指向的数据，就是队头数据

详细代码如下：


typedef struct {
    int* arr;
    int front;
    int rear;
    int num;
} MyCircularQueue;

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

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {

    return (obj->rear == obj->front);
}

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {

    if (myCircularQueueIsFull(obj)) // 队列满了
    {
        return false;
    }
    // 插入数据
    obj->arr[obj->rear++] = value;
    obj->rear %= (obj->num + 1);
    return true;
}

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

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return -1;
    int ret=obj->rear-1;
    if(obj->rear==0)
    {
        ret=obj->num;
    }
    return obj->arr[ret];
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->arr);
    free(obj);
    obj = NULL;
}

感谢各位大佬支持并指出问题，

                        如果本篇内容对你有帮助，可以一键三连支持以下，感谢支持！！！

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

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

相关文章

认识和安装R的扩展包，什么是模糊搜索安装，工作目录和空间的区别与设置

认识和安装R的扩展包，什么是模糊搜索安装，工作目录和空间的区别与设置

R语言以其强大的功能和灵活的扩展性，成为了无数数据分析师和研究者的首选工具。R的丰富功能和海量扩展包直接相关，但如何高效管理这些扩展包，进而充分发挥R的强大潜力？本文将为您揭示这些问题的答案。 一、R的扩展包 R的包（packages）是由R函数、数据和预编译代码组成的一…
阅读更多...
PyQT6---环境搭建

PyQT6---环境搭建

1、虚拟环境搭建 创建虚拟环境 create -n pyqt6_39 python3.9 切换虚拟环境 conda activate pyqt6_39 2、安装pyqt6 安装pyqt6和pyqt6-tools pip install PyQt6 -i https://pypi.tuna.tsinghua.edu.cn/simplepip install pyqt6-tools -i https://pypi.tuna.tsinghua.edu.cn/…
阅读更多...
关卡1-3：Git

关卡1-3：Git

关卡1-3&#xff1a;Git Git基础fork并拉取本次课程的源创建一个gitee自己的仓库 这个是internLM的3期训练营的通关笔记。 任务&#xff1a; 熟悉git熟悉使用git托管平台&#xff0c;常见有github、giteefork官方的训练营的教程项目&#xff0c;提交文件到自己的项目&#xf…
阅读更多...
算法力扣刷题记录 五十六【501.二叉搜索树中的众数】

算法力扣刷题记录 五十六【501.二叉搜索树中的众数】

前言 二叉搜索树操作&#xff0c;继续。 记录 五十六【501.二叉搜索树中的众数】 一、题目阅读 给你一个含重复值的二叉搜索树&#xff08;BST&#xff09;的根节点 root &#xff0c;找出并返回 BST 中的所有 众数&#xff08;即&#xff0c;出现频率最高的元素&#xff09;…
阅读更多...
基于机器学习的二手房价格分析与预测设计与实现

基于机器学习的二手房价格分析与预测设计与实现

概述 随着西安房地产市场的不断发展和变化&#xff0c;对二手房价格的准确预测变得至关重要。本研究旨在利用机器学习技术对西安市二手房价格进行深入分析与预测&#xff0c;通过对原始数据进行数据预处理和特征提取&#xff0c;以构建有效的预测模型。通过数据分析和可视化&a…
阅读更多...
IP数据报结构详解：从基础到进阶

IP数据报结构详解：从基础到进阶

目录 IP数据报的格式 IP数据报首部的固定部分 IP数据报首部的可变部分 实例分析&#xff1a;数据报的分片 生存时间&#xff08;TTL&#xff09;与协议 首部检验和 总结 在网络通信中&#xff0c;IP数据报是至关重要的基本单元。本文将带您深入了解IP数据报的格式及其各个…
阅读更多...
Java | Leetcode Java题解之第264题丑数II

Java | Leetcode Java题解之第264题丑数II

题目&#xff1a; 题解&#xff1a; class Solution {public int nthUglyNumber(int n) {int[] dp new int[n 1];dp[1] 1;int p2 1, p3 1, p5 1;for (int i 2; i < n; i) {int num2 dp[p2] * 2, num3 dp[p3] * 3, num5 dp[p5] * 5;dp[i] Math.min(Math.min(num2…
阅读更多...
C语言顺序表插入删除 尾删 任意删除 任意插入 链表头插

C语言顺序表插入删除 尾删 任意删除 任意插入 链表头插

各位少年&#xff0c;大家好我是小敖 &#xff0c;今天给大家分享 顺序表的头删 尾删&#xff0c;任意删除&#xff0c;任意插入&#xff0c;链表头插。接下来跟大家分享。 头插的操作 c void SLPushFront(SL*psl, SLDatatype x) {SLCheckCapacity(psl); int end psl->siz…
阅读更多...
stm32平台为例的软件模拟时间，代替RTC调试

stm32平台为例的软件模拟时间，代替RTC调试

stm32平台为例的软件模拟时间&#xff0c;代替RTC调试 我们在开发项目的时候&#xff0c;如果用到RTC&#xff0c;如果真正等待RTC到达指定的时间&#xff0c;那调试时间就太长了。 比如每隔半个小时&#xff0c;存储一次数据&#xff0c;如果要观察10次存储的效果&#xff0…
阅读更多...
nginx通过nginx_upstream_check_module实现后端健康检查

nginx通过nginx_upstream_check_module实现后端健康检查

1、简介说明 nginx是常用的反向代理和负载均衡服务&#xff0c;具有强大并发能力、稳定性、丰富的功能集、低资源的消耗。 nginx自身是没有针对后端节点健康检查的&#xff0c;但是可以通过默认自带的ngx_http_proxy_module 模块和ngx_http_upstream_module模块中的相关指令来完…
阅读更多...
LDR6020双盲插便携显示器应用

LDR6020双盲插便携显示器应用

随着USB Type-C接口的普及&#xff0c;越来越多的手机和笔记本电脑都支持通过C接口输出视频。这个小巧而精密的接口&#xff0c;大有把传统的HDMI和DisplayPort接口取而代之的架势。特别是usb4的推出&#xff0c;更是为USB TYPE-C接口一统有线接口形态奠定了基础。 单USB-C接口…
阅读更多...
电子电器架构 - SOA架构软件平台

电子电器架构 - SOA架构软件平台

电子电器架构 - SOA架构软件平台 我是穿拖鞋的汉子，魔都中坚持长期主义的汽车电子工程师。 老规矩，分享一段喜欢的文字，避免自己成为高知识低文化的工程师： 屏蔽力是信息过载时代一个人的特殊竞争力，任何消耗你的人和事，多看一眼都是你的不对。非必要不费力证明自己，无…
阅读更多...
Django transaction.atomic()事务处理

Django transaction.atomic()事务处理

在Django中&#xff0c;transaction.atomic()是一个上下文管理器&#xff0c;它会自动开始一个事务&#xff0c;并在代码块执行完毕后提交事务。如果在代码块中抛出异常&#xff0c;事务将被自动回滚&#xff0c;确保数据库的一致性和完整性。 在实际应用中&#xff0c;你可能需…
阅读更多...
深入浅出WebRTC—ULPFEC

深入浅出WebRTC—ULPFEC

FEC 通过在发送端添加额外的冗余信息&#xff0c;使接收端即使在部分数据包丢失的情况下也能恢复原始数据&#xff0c;从而减轻网络丢包的影响。在 WebRTC 中&#xff0c;FEC 主要有两种实现方式&#xff1a;ULPFEC 和 FlexFEC&#xff0c;FlexFEC 是 ULPFEC 的扩展和升级&…
阅读更多...
8.持久化

8.持久化

队列和消息都可以持久化。 持久化的目的就是让消息不丢失。 RabbitMQ本身退出&#xff0c;或者由于某种原因崩溃时造成的消息丢失。 RabbitMQ一旦宕机&#xff0c;就会造成队列和消息都丢失了。 RabbitMQ重启之后&#xff0c;非持久化的队列和消息都不存在了。 队列持久化…
阅读更多...
项目部署--最原始的方法

项目部署--最原始的方法

服务器环境搭建 以腾讯云为例&#xff1a; 1.可以先用这个使用一个月的 2.访问服务器官网&#xff1a;腾讯云官网&#xff0c;进去先登录&#xff0c;再点击 控制台&#xff0c;找到 轻量应用服务器&#xff0c;进去之后会看见使用的服务器&#xff0c;有一个 公网IP&#xff…
阅读更多...
[Spring Boot]Protobuf解析MQTT消息体

[Spring Boot]Protobuf解析MQTT消息体

简述 本文主要针对在MQTT场景下&#xff0c;使用Protobuf协议解析MQTT的消息体 Protobuf下载 官方下载 https://github.com/protocolbuffers/protobuf/releases网盘下载 链接&#xff1a;https://pan.baidu.com/s/1Uz7CZuOSwa8VCDl-6r2xzw?pwdanan 提取码&#xff1a;an…
阅读更多...
C语言：数组-学习笔记（万字笔记）——翻新版

C语言：数组-学习笔记（万字笔记）——翻新版

目录 前言&#xff1a; 1、 数组的概念 1.1 什么是数组 1.2 为什么学习数组&#xff1f; 2. ⼀维数组的创建和初始化 2.1 数组创建 2.2 数组的初始化 2.3 数组的类型 2.3.1 什么是数组类型&#xff1f; 2.3.2 数组类型的作用 3、 一维数组的使用 3.1 数组下标 3.2 数…
阅读更多...
ZYNQ 入门笔记（零）：概述

ZYNQ 入门笔记（零）：概述

文章目录 引言产品线Zynq™ 7000 SoCZynq UltraScale™ MPSoCZynq UltraScale RFSoCVersal™ Adaptive SoC 开发环境 引言 Xilinx FPGA 产品线从经济型的 Spartan、Artix 系列到高性能的 Kintex、Virtex、Versal 系列&#xff0c;可以说涵盖了 FPGA 的绝大部分应用场景&#x…
阅读更多...
SpringBoot 最大连接数及最大并发数是多少

SpringBoot 最大连接数及最大并发数是多少

SpringBoot 最大连接数及最大并发数 Spring Boot 是一个基于 Spring 框架的快速开发框架&#xff0c;它本身并不直接管理数据库连接或网络连接的最大连接数和最大并发数。这些参数通常由底层的基础设施和组件来控制&#xff0c;例如&#xff1a; 数据库连接池&#xff1a;Spri…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023