栈和队列题目练习

news2024/10/6 20:36:04

本节小编选了两道题来加深对栈和队列的认识理解！

有效的括号

方法1：直接用栈的结构（动态数组）

本题可以用栈这个结构来解答，将'(','{','['  左括号压入栈中，然后取出栈顶元素与右括号')','}',']'匹配。不匹配的话，返回false,我们同时也要考虑空集的情况，即栈中元素为空，则返回false。

因为本题使用c语言写的，所以需要手撕栈的结构，可以运用上篇博客所写的栈的代码。

typedef  char  datatype;
typedef struct stack {
	datatype* a;
	int top;//栈顶
	int capacity;
}ST;
void STInit(ST* pst){
	assert(pst);
	pst->a = NULL;
	//top指向栈顶数据的下一个位置,可以理解为下标
	pst->top = 0;
	pst->capacity = 0;
}
void STDestory(ST* pst) {
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}
//容量检查
void Checkcapacity(ST* pst) {
	assert(pst);
	if (pst->top == pst->capacity) {
		int newcapacity = pst->capacity==0?4:pst->capacity * 2;
		datatype* temp = (datatype*)realloc(pst->a, newcapacity * sizeof(datatype));
		if (temp == NULL) {
			perror("relloc fail");
			return;
		}
		pst->a = temp;
		pst->capacity = newcapacity;
	}
}
//入栈和出栈
void STPush(ST* pst, datatype x) {
	assert(pst);
	Checkcapacity(pst);
	pst->a[pst->top] = x;
	pst->top++;
}
void STPop(ST* pst) {
	assert(pst);
	assert(pst->top>0);
	pst->top--;
}
//获取栈顶数据
datatype STTop(ST* pst) {
	assert(pst);
	assert(pst->top > 0);
	return pst->a[pst->top-1];
}
//判空
bool STEmpty(ST* pst) {
	assert(pst);
	return pst->top == 0;//表达式判断
}
//栈的数据个数
int STSize(ST* pst) {
	assert(pst);
	return pst->top;
}
bool isValid(char* s) {
    ST st;
    STInit(&st);
    while(*s){
        //左括号入栈
        if(*s=='('||*s=='{'||*s=='['){
            STPush(&st,*s);
        }
    else{
       //空集的情况，入栈结束后检查是否为空，
        if(STEmpty(&st)){
        STDestory(&st);
        return false;
        }
        char top=STTop(&st);
        STPop(&st);
       //通过括号不匹配的情况判断
        if((top=='('&& *s!=')') ||(top=='['&& *s!=']')||(top=='{'&& *s!='}')){
        STDestory(&st);
        return false;
        //STPop(&st);
    }
    }
    s++;
    }
//看最后是否栈为空，探讨左右括号数量不匹配的情况。
   bool ret=(STEmpty(&st));
     STDestory(&st);
     return ret;
}

方法2：通过数组模拟栈来实现

使用一个字符数组作为栈，通过使用top标记栈顶的位置来实现栈的操作。在遍历字符串的过程中，遇到左括号就将其压入栈中，遇到右括号就与栈顶元素进行匹配。如果匹配成功，则将栈顶元素出栈，否则返回false。最后，如果栈为空，则说明所有的括号都匹配成功，返回true；否则，返回false。

bool isValid(char* s) {
    char stack[10000];
    int top = -1;
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        if (s[i] == '(' || s[i] == '{' || s[i] == '[') {
            stack[++top] = s[i];
        } else {
            if (top == -1) {
                return false;
            }
            
            if ((s[i] == ')' && stack[top] == '(') || 
                (s[i] == '}' && stack[top] == '{') || 
                (s[i] == ']' && stack[top] == '[')) {
                top--;
            } else {
                return false;
            }
        }
    }
    
    return top == -1;
}

设计循环队列

方法1:使用动态数组

通过画图发现，当head==tail时，既是队列为空的条件，也是队列满的条件，所以我们可以通过增加一个空间来辅助判满，当tail+1=head时。还有另外一个方法，通过定义size变量，当size大小等于k时，也是队列满的时候。

在后续解决回绕的问题时，我们多次采用取模的方法，因为一个数除以比他大的数，取模后大小不变，当相等时，模为0，刚好回到起点处，完美的解决了回绕问题。



//循环队列先进先出
typedef struct {
    int *arr;
    int head;
    int tail;//指向尾下一个
    int k;
} MyCircularQueue;

//创建循环队列
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //多开辟一个空间
	obj->arr=(int*)malloc(sizeof(int)*(k+1));
    
	obj->head=0;
    obj->tail=0;
    obj->k=k;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    //头尾相等时队列为空
	return (obj->head)==obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    //当tail+1=head时，为满，通过取模解决回绕问题
	return((obj->tail+1)%(obj->k+1))==obj->head;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //队列满的时候，返回false
	if(myCircularQueueIsFull(obj))
    return false;
    //插入一个数据，tail后移
	obj->arr[obj->tail]=value;
    obj->tail++;
    //解决回绕，重头再来
    obj->tail %=(obj->k+1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return false;
    //head前进，删除数据
	obj->head++;
	//解决回绕问题
    obj->head %=(obj->k+1);
    return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return -1;
    else
    //分类讨论取尾元素
    return obj->tail==0?obj->arr[obj->k]:obj->arr[obj->tail-1];
    //return obj->arr[(obj->tail-1+obj->k+1)%(obj->k+1)];//取模的方法很巧妙
}

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

方法2：双向链表实现

使用双向链表实现，其中每个节点（Node）包含一个整数值（val），以及指向前一个节点和后一个节点的指针（prev和next）。循环队列（MyCircularQueue）包含一个指向队列头部和尾部的指针（head和tail），以及队列的大小（size）和容量（capacity）。

//节点建立
typedef struct Node {
    int val;
    struct Node* prev;
    struct Node* next;
} Node;
//双向链表实现队列
typedef struct {
    Node* head;
    Node* tail;
    int size;
    int capacity;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->head = NULL;
    obj->tail = NULL;
    obj->size = 0;
    obj->capacity = k;
    return obj;
}
//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->size == 0;
}
//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->capacity;
}
//插入数据
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj)) {
        return false;
    }

    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->val = value;
    newNode->prev = NULL;
    newNode->next = NULL;
 //队列为空时
    if (myCircularQueueIsEmpty(obj)) {
        obj->head = newNode;
        obj->tail = newNode;
        newNode->next = newNode;
        newNode->prev = newNode;
    } 
  // 不为空时
 
else {
        newNode->prev = obj->tail;
        newNode->next = obj->head;
        obj->tail->next = newNode;
        obj->head->prev = newNode;
        obj->tail = newNode;
    }
    obj->size++;
    return true;
}
//数据的删除
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) {
        return false;
    }

    Node* del = obj->head;
    if (obj->size == 1) {
        obj->head = NULL;
        obj->tail = NULL;
    } else {
        obj->head = obj->head->next;
        obj->head->prev = obj->tail;
        obj->tail->next = obj->head;
    }

    obj->size--;
    free(del);
    return true;
}
//头数据
int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) {
        return -1;
    }
    return obj->head->val;
}
//尾数据
int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) {
        return -1;
    }
    return obj->tail->val;
}
//队列销毁
void myCircularQueueFree(MyCircularQueue* obj) {
    Node* curr = obj->head;
    while (curr != obj->tail) {
        Node* next = curr->next;
        free(curr);
        curr = next;
    }
    obj->tail=NULL;

    free(obj);
}

补充方法3：

使用链表（单链表）-投机取巧哈哈哈

不过这种方法没有关系到循环队列，也能通过该题目。

可以用链表实现队列，用链表实现队列则较为简单，因为链表可以在 O(1)时间复杂度完成插入与删除。入队列时，将新的元素插入到链表的尾部；出队列时，将链表的头节点返回，并将头节点指向下一个节点。

循环队列的属性如下:

head：链表的头节点，队列的头节点。
tail：链表的尾节点，队列的尾节点。
capacity：队列的容量，即队列可以存储的最大元素数量。
size：队列当前的元素的数量。

相比较与数组，我们使用了size的方法来判断队列为空为满的状态，

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
//中间节点创建和函数主体
typedef struct node {
    int val;
    struct node* next;
} node;
//循环队列先进先出
typedef struct {
    node* head;
    node* tail;
    int size;
    int capacity;
} MyCircularQueue;

//创建循环队列
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->head=obj->tail=NULL;
    obj->size=0;
    obj->capacity=k;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
   if(obj->size==0)
   return true;
   else
   return false;
//return obj->size==0;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size==obj->capacity;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    return false;
    node* newnode=(struct node*)malloc(sizeof(node));
    newnode->val=value;
    newnode->next=NULL;
    if(obj->size==0)
    {
        obj->head=newnode;
        obj->tail=newnode;
    }
    else{
    obj->tail->next=newnode;
    obj->tail=newnode;
    }
    obj->size++;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return false;
    node*del=obj->head;
    obj->head=obj->head->next;
    free(del);
    obj->size--;
    return true;

}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return -1;
    return obj->head->val;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return -1;
    return obj->tail->val;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    node* curr = obj->head;
    while (curr != NULL) {
        node* next = curr->next;
        free(curr);
        curr = next;
    }
    
    obj->size = obj->capacity = 0;
    obj->head = obj->tail = NULL;
    free(obj);
}

//手动测试部分
int main() {
    MyCircularQueue* obj = myCircularQueueCreate(5);
    myCircularQueueEnQueue(obj, 1);
    myCircularQueueEnQueue(obj, 2);
    myCircularQueueEnQueue(obj, 3);
    myCircularQueueEnQueue(obj, 4);
    myCircularQueueEnQueue(obj, 5);
    printf("%d\n", myCircularQueueRear(obj));
    printf("%d\n", myCircularQueueFront(obj));
    myCircularQueueDeQueue(obj);
    printf("%d\n", myCircularQueueFront(obj));
    myCircularQueueFree(obj);
    return 0;
}

OK，本节内容到此结束，各位友友留下三连和评论吧，有更好的方法希望各位佬私信交流！！！

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

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

相关文章

雅特力串口485模式TCDT/TSDT说明

雅特力串口485模式TCDT/TSDT说明

TCDT&#xff08;发送器完成延迟时间&#xff08;transmit complete delay time&#xff09;占了5个bit位&#xff0c;则最大值为 2 5 − 1 31 2^{5} -1 31 25−131&#xff0c;时间单位是 1 16 波特率周期 \frac{1}{16}波特率周期 161​波特率周期 波特率为9600&#xff…
阅读更多...
如何理解 Java 接口和抽象类的定义和使用场景

如何理解 Java 接口和抽象类的定义和使用场景

Java 是一种面向对象编程语言&#xff0c;提供了丰富的面向对象编程机制。其中&#xff0c;接口和抽象类是两个重要的概念&#xff0c;它们在设计和实现代码时扮演着关键的角色。 接口&#xff08;Interface&#xff09; 定义和特性 接口是 Java 中的一种引用数据类型&#…
阅读更多...
神经网络与深度学习——第4章 前馈神经网络

神经网络与深度学习——第4章 前馈神经网络

本文讨论的内容参考自《神经网络与深度学习》https://nndl.github.io/ 第4章 前馈神经网络 前馈神经网络 神经元 Sigmoid型函数 Hard-Logistic函数和Hard-Tanh函数 ReLU函数 带泄露的ReLU 带参数的ReLU ELU函数 Softplus函数 Swish函数 GELU函数 Maxout单元 网络结构 前馈网络…
阅读更多...
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案

JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案

前言 在并发编程时&#xff0c;常常会出现线程安全问题&#xff0c;那么如何保证原子性呢&#xff1f;常用的方法就是加锁。在Java语言中可以使用 Synchronized和CAS实现加锁效果。  Synchronized关键字保证同步的&#xff0c;这会导致有锁&#xff0c;但是锁机制存在以下问题…
阅读更多...
当你想使用预测概率作为预测模型的结果

当你想使用预测概率作为预测模型的结果

&#x1f31f;当你想使用预测概率作为医学预测模型的结果&#x1f31f; 分类预测模型的预测结果有两种。一种是直接判断是哪一类&#xff0c;这种情况下唯一可以调节的就是决策阈值&#xff0c;或者是默认的0.5&#xff0c;也可以是参数确定的决策阈值&#xff0c;比如约登指数…
阅读更多...
ELK 使用 metricbeat监控数据

ELK 使用 metricbeat监控数据

IP功能版本192.168.140.153elk-18.13.4192.168.140.153metricbeat8.13.4192.168.140.156elk-28.13.4192.168.140.156metricbeat8.13.4192.168.140.159logstash8.13.4192.168.140.159kibana8.13.4 一、安装ELK 参考文档&#xff1a; https://download.csdn.net/download/weix…
阅读更多...
Spring 源码：深度解析AOP源码配置解析

Spring 源码：深度解析AOP源码配置解析

文章目录 一、 解析AOP配置的入口1.1 从XML配置到AOP Namespace的解析流程1.2 分析注解驱动的AOP配置解析流程 二、AOP配置解析的核心流程2.1 ConfigBeanDefinitionParser 类2.2 parse()2.3 parseAdvisor()2.4 parseAspect()2.5 parsePointcut()2.6 createAdvisorBeanDefinitio…
阅读更多...
CentOS 7基础操作02_优化Linux操作系统中的服务

CentOS 7基础操作02_优化Linux操作系统中的服务

1、实验环境 公司在文件服务器中新安装了CentOS系统.由于默认启动的服务程序较多&#xff0c;系统运行缓慢。现需要对系绞服务进行适当优化&#xff0c;减少一些不必要的自启动服务.并设置系统在开机后直接进入字符模式。 2、需求描述 根据实际使用需求对CentOS 7操作系统中的…
阅读更多...
C++第二十二弹---vector深度剖析及模拟实现(下)

C++第二十二弹---vector深度剖析及模拟实现(下)

✨个人主页&#xff1a; 熬夜学编程的小林 &#x1f497;系列专栏&#xff1a; 【C语言详解】 【数据结构详解】【C详解】 目录 1、容量操作 2、内容修改操作 3、打印函数 4、迭代器失效 4.1、什么是迭代器失效 4.2、哪些操作会引起迭代器失效 总结 1、容量操作 size()…
阅读更多...
【Docker】宝塔创建Docker容器配置nginx

【Docker】宝塔创建Docker容器配置nginx

前言 本篇是我入门docker的第一篇&#xff0c;由于docker具有很好的移植性&#xff0c;易于安装&#xff0c;开箱即用&#xff1b;签约的公司项目开发需要我进行学习&#xff0c;否则money减半&#xff0c;5555~ 百度找了一圈&#xff0c;只有关于docker怎么装宝塔服务器的却没…
阅读更多...
从Socket到WebSocket

从Socket到WebSocket

前言 不知道大家在学习网络编程的时候都是怎样的一种方式&#xff0c;我谨以此文章来记录我自己从头开始学习C网络编程时的经历&#xff0c;中间有许多我自己的一些想法和思考。当然作为一个刚开始学习的新手来说&#xff0c;有些内容也许不那么正确&#xff0c;只是代表了我在…
阅读更多...
【Qt知识】Qt Creator快捷键

【Qt知识】Qt Creator快捷键

以下是Qt Creator中的一些常用快捷键列表&#xff08;持续更新&#xff09;&#xff1a; 基本编辑 多行注释/取消多行注释: Ctrl /编译工程: Ctrl B运行工程: Ctrl R整行上移/下移: Ctrl Shift ↑/↓查找: Ctrl F函数声明和定义切换: F2向下查找: F3头文件和源文件切换:…
阅读更多...
SAPUI5基础知识3 - 引导过程（Bootstrap）

SAPUI5基础知识3 - 引导过程（Bootstrap）

1. 背景 在上一篇博客中&#xff0c;我们已经建立出了第一个SAPUI5项目&#xff0c;接下来&#xff0c;我们将为这个项目添加引导过程。 在动手练习之前&#xff0c;让我们先解释一下什么引导过程。 1.1 什么是引导过程&#xff1f; 在计算机科学中&#xff0c;引导过程也称…
阅读更多...
苹果如何设置自动循环壁纸？这几种不同的方法你要学会

苹果如何设置自动循环壁纸？这几种不同的方法你要学会

在使用手机的时候&#xff0c;我们可能会经常更换手机壁纸&#xff0c;遇见好看或者有意义的图片时就想将其设置为壁纸&#xff0c;你知道 iPhone 手机可以设置自动循环壁纸吗&#xff1f;如果你不了解下面就带你一起看看 iPhone 手机如何设置壁纸自动循环。 壁纸程序设置 想…
阅读更多...
GIS之arcgis系列06：线划图缓冲区分析

GIS之arcgis系列06：线划图缓冲区分析

缓冲区工具将在输入要素周围指定距离内创建缓冲区面。 缓冲区例程将遍历输入要素的每个折点并创建缓冲区偏移。 通过这些偏移创建输出缓冲区要素 原理&#xff1a; 01.打开文件 02.确定单位&#xff0c;在文件属性里。 03.工具箱-->分析工具-->邻域分析-->缓冲区。 …
阅读更多...
藏汉翻译通小程序——你口袋里的藏语翻译助手！支持高精度藏文OCR文字识别提取，安卓iPhone手机都能用的藏汉翻译小助手！

藏汉翻译通小程序——你口袋里的藏语翻译助手！支持高精度藏文OCR文字识别提取，安卓iPhone手机都能用的藏汉翻译小助手！

想要快速学习藏语或者与藏族朋友无障碍沟通吗&#xff1f;藏汉翻译通小程序绝对是你的不二之选&#xff01; 这款小程序不仅界面简洁、操作便捷&#xff0c;更重要的是它集合了多种实用功能于一身。 双语翻译&#xff1a;无论你是藏族还是汉族&#xff0c;只需输入文字&#…
阅读更多...
C#中的实体属性详解与示例

C#中的实体属性详解与示例

文章目录 实体属性的定义实体属性的访问实体属性的示例总结 在C#中&#xff0c;实体属性是面向对象编程的重要组成部分。实体属性允许我们定义对象的特征和行为&#xff0c;并提供了一种方式来访问和管理这些特征。通过实体属性&#xff0c;我们可以封装对象的状态&#xff0c;…
阅读更多...
【Linux】Linux基本指令3

【Linux】Linux基本指令3

目录 1.date指令 2.cal指令 3.find指令&#xff1a;&#xff08;灰常重要&#xff09; -name 4.grep指令——行文本过滤工具 5.zip/unzip指令&#xff1a; 6.tar指令&#xff08;重要&#xff09;&#xff1a;打包/解包&#xff0c;不打开它&#xff0c;直接看内容 7.bc…
阅读更多...
OSPF学习笔记（状态机）

OSPF学习笔记（状态机）

1、邻居关系 OSPF设备启动后&#xff0c;会通过OSPF接口向外发送Hello报文&#xff0c;收到Hello报文的OSPF设备会检查报文中所定义的参数&#xff0c;如果双方一致就会形成邻居关系&#xff0c;两端设备互为邻居 2、邻接关系 形成邻居关系后&#xff0c;如果两端设备成功交…
阅读更多...
Spring boot集成通义千问大模型

Spring boot集成通义千问大模型

Spring boot集成通义千问大模型 背景 我在用idea进行java开发时发现了通义灵码这款免费的智能代码补全插件&#xff0c;用了一段时间了&#xff0c;感觉很不错。就想着在自己的项目中也能集成通义千问大模型实现智能回答&#xff0c;毕竟对接openai需要解决网络问题&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023