栈与队列的oj题

最新推荐文章于 2024-07-25 11:27:31 发布
最新推荐文章于 2024-07-25 11:27:31 发布
阅读量973 收藏 28
点赞数 17
文章标签： 算法 数据结构 开发语言 学习 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/comeonworld/article/details/138791581
版权

前言

本次博客做题为主，直接开始

第一题

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

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号

分析

首先它是一个括号匹配的问题，括号匹配就意味着一 一对应

那么谁先对应谁后对应呢？

比如 对于一个(来说它要找到 ‘)’  但是之后如果字符串下一个字符为[

那么[必须要先匹配之后才轮到（对吧

是不是刚好符合栈的定义，后进先出，比对完后面的在比对前面

那么，我们就用栈来存储数据

那么接下来就该讨论情况了

1 如果字符串的个数为奇数，那么它一定不匹配，这是不用质疑的，那么接下来的情况就都是

偶数个数了

2如果第一个元素就为右括号，那么它就一定不匹配，当然，这个第一个元素不精确

我们可以扩展一下，那就是栈为空时，接收的元素为有括号那么它就一定不匹配

3普通不匹配情况：普通不匹配  比如 用(匹配}  用 { 匹配 ]等等情况

4就是遇到两个朝右方向的字符 那么存储继续

接下来就具体模拟一下流程

我们让栈记录与括号方向相反的括号，比如字符串中 第一个是 '{' 那么在栈中存储'}'

这样在下一次的比对中可以直接判断他们是否相等，而不是判断是不是对应括号

如果相等，让栈直接pop，如果不等那就是不匹配，这样巧妙的解决了问题

当然，我们也可以记录相同方向的括号，只不过在比较是发生了变化

看代码吧

class Solution {
public:
    bool isValid(string s) {
        stack<char>st;
        for(int i=0;i<s.size();i++)
        {
            if(s[i]=='('||s[i]=='['||s[i]=='{')
            st.push(s[i]);
            else if(s[i]==')'&&!st.empty()&&st.top()=='(')
            st.pop();
            else if(s[i]==']'&&!st.empty()&&st.top()=='[')
            st.pop();
            else if(s[i]=='}'&&!st.empty()&&st.top()=='{')
            st.pop();
            else
            return false;
        }
        return st.empty();
    }
};

最后不要忘了，要返回st.empty()

因为会有没有进行过一次比较的情况

比如 ((  这种情况没有右括号

第二题

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

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 

分析

使用队列实现栈时，我们还是画图来分析吧

看图

OK看代码吧

typedef struct Queue {
	struct Queue_* head;
	struct Queue_* tail;
	int size;
}Que;
typedef struct Queue_ {
	struct Queue_* next;
	int val;
}Que_;
void InitQue(Que* que)
{
	que->size = 0;
	que->tail=que->head = NULL;
}
void PushQue(Que* que, int val)
{
	Que_* newnode = (Que_*)malloc(sizeof(Que_));
	newnode->val = val;
	newnode->next = NULL;
	if (que->head == NULL)
	{
		que->head = que->tail = newnode;
	}
	else
	{
		que->tail->next=newnode;
		que->tail = newnode;
	}
	que->size++;
}
void PopQue(Que* que)
{
	if (que->head == que->tail)
	{
		free(que->head);
		que->head = que->tail = NULL;
	}
	else
	{
		Que_* temp = que->head->next;
		free(que->head);
		que->head = temp;
	}
	que->size--;
}
bool EmptyQue(Que* que)
{
	return que->size == 0;
}
int FrontQue(Que* que)
{
    assert(que->head);
	return que->head->val;
}
int BackQue(Que* que)
{
    assert(que->head);
	return que->tail->val;
}
int SizeQue(Que* que)
{
	return que->size;
}
void DestroyQue(Que*que)
{
    free(que->head);
    que->size=0;
    que->head=que->tail=NULL;
}
typedef struct {
    Que que1;
    Que que2;
} MyStack;
MyStack* myStackCreate() {
    MyStack*st=(MyStack*)malloc(sizeof(MyStack));
    InitQue(&st->que1);
    InitQue(&st->que2);
    return st;
}
void myStackPush(MyStack* obj, int x) {
    if(!EmptyQue(&obj->que1))
    {
        PushQue(&obj->que1,x);
    }
    else
    {
        PushQue(&obj->que2,x);
    }
}
int myStackPop(MyStack* obj) {
    //采用假设法
    Que *a=&obj->que1;
    Que *b=&obj->que2;
    if(EmptyQue(&obj->que1))
    {
     a=&obj->que2;
     b=&obj->que1;
    }
    while(SizeQue(a)>1)
    {
        PushQue(b,a->head->val);
        PopQue(a);
    }
    int ret=FrontQue(a);
    PopQue(a);
    return ret;
}
int myStackTop(MyStack* obj) {

    Que *a=&obj->que1;
    Que *b=&obj->que2;
    if(EmptyQue(&obj->que1))
    {
     a=&obj->que2;
     b=&obj->que1;
    }
    return BackQue(a);
}
bool myStackEmpty(MyStack* obj) {
    
    return EmptyQue(&obj->que1)&&EmptyQue(&obj->que2);
}
void myStackFree(MyStack* obj) {
    DestroyQue(&obj->que1);
    DestroyQue(&obj->que2);
    free(obj);
}

第三题

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

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

这个题目与上个题目差不多

分析部分还是看图快一点

 看代码

typedef int DataType;
typedef struct Stack {
	DataType* a;
	int top;
	int capacity;
}ST;
void InitStack(ST* st)
{
	assert(st);
	st->a = NULL;
	st->capacity = 0;
	st->top = 0;
}
DataType TopStack(ST* st)
{
	assert(st);
	assert(st->top > 0);
	return st->a[st->top - 1];
}
void PushStack(ST* st, DataType x)
{
	assert(st);
	if (st->a == NULL)
	{
		st->a=(DataType*)malloc(sizeof(DataType)*4);
		st->capacity = 4;
		st->a[st->top++] = x;
	}
	else
	{
		if (st->capacity == st->top)
		{
			DataType* temp = (DataType*)realloc(st->a, sizeof(DataType) * 2 * st->capacity);
			if (temp != NULL)
			{
				st->a =temp;
				st->capacity *= 2;
			}
		}
		st->a[st->top++] = x;
	}
}
void PopStack(ST* st)
{
	assert(st);
	assert(st->top > 0);
	st->top--;
}
int SizeStack(ST* st)
{
	return st->top;
}
DataType BottomStack(ST* st)
{
	assert(st);
	assert(st->top > 0);
	return st->a[0];
}
void DestroyStack(ST* st)
{
	free(st->a);
	st->a = NULL;
	st->capacity = 0;
	st->top = 0;
}
bool EmptyStack(ST* st)
{
	return st->top == 0;
}
typedef struct {
    ST st1;
    ST st2;
} MyQueue;
MyQueue* myQueueCreate() {
    MyQueue*que=(MyQueue*)malloc(sizeof(MyQueue));
    InitStack(&que->st1);
    InitStack(&que->st2);
    return que;
}
void myQueuePush(MyQueue* obj, int x) {
    PushStack(&obj->st1,x);
}
int myQueuePop(MyQueue* obj) {
    int ret=myQueuePeek(obj);
    PopStack(&obj->st2);
    return ret;
}
int myQueuePeek(MyQueue* obj) {
   if(EmptyStack(&obj->st2))
   {
    while(!EmptyStack(&obj->st1))
    {
        int ret=TopStack(&obj->st1);
        PushStack(&obj->st2,ret);
        PopStack(&obj->st1);
    }
   }
   int re=TopStack(&obj->st2);
    return re;
}
bool myQueueEmpty(MyQueue* obj) {
    return EmptyStack(&obj->st1)&&EmptyStack(&obj->st2);
}

void myQueueFree(MyQueue* obj) {
    DestroyStack(&obj->st1);
    DestroyStack(&obj->st2);
    free(obj);
}

 第四题

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

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

OK这里要提醒各位，什么事循环队列

1大小固定

2内存利用满

3有队头队尾，一旦满队就不能插入元素了

这个题目可以使用数组以及队列来实现

本次博客使用数组来实现

细节

如何初始化，如何判断队列满，以及队列为空

初始化也同时决定了判满以及判空

1我们可以使用多开一个空间

2我们可以增加一个结构体变量size

本人更加倾向于第二种，因为第一种更加抽象，

使用多开空间实现判空，以及判满

当然在这之前，我们要先初始化队尾与队头，

我们一开始让队尾与队头为0，队尾为最后元素的下一个

插入元素，队尾++ 删除元素 队头++

不管是那种方法，判空时:我们都应该清楚，队头等于队尾时队列为空

当然，对于增加结构体变量size这个情况 可以直接与0比较

那么判满时，对于size而言，直接与队列的容量相比

但是对于增加一个容量来说有两种情况要考虑，这时可以使用求余

具体看图吧

OK，接下来来看看

插入，删除，取队头，取队尾的操作吧！

为了方便理解，我们下面的代码采用增加一个size成员变量来理解

插入元素

很简单，如果栈不为满，在队尾的位置插入元素然后tail++

当然这里同样要取余，因为，tail可能会循环一遍队列，所以tail=(tail+1)%(k)

删除元素

也同样简单，如果栈不为空，头head++即可，但是队头也有可能会回循环一遍队列

所以head=(head+1)%k

取队头

简单，只要栈不为空，返回head所指向的值即可

取队尾

有两种情况

这里要画个图来理解

OK，看代码吧

typedef struct {
    int *a;
    int k;
    int front;
    int rear;
    int size;
} MyCircularQueue;
bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int *)malloc(sizeof(int)*(k));
    obj->front=obj->rear=0;
    obj->k=k;
    obj->size=0;
    return obj;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->rear]=value;
        obj->rear=(obj->rear+1)%(obj->k);
        obj->size++;
        return true;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front=(obj->front+1)%(obj->k);
        obj->size--;
        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
    {
        int ret=(obj->rear-1+obj->k)%(obj->k);
        return obj->a[ret];
    }
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->size==0;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size==obj->k;
}

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

总结

这几道oj题主要还是运用了栈与队列的特性

希望在以后对于数据的处理上，我们可以多一种思维方式，好吧就到这里了

 

 

 

 

 

come on world
关注
  • 17
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
栈与队列OJ题
Odfogy的博客
08-21 169
1、栈与队列的实现 //队列 ListNode*BuyListNode(LTDataType x) { ListNode *node = (ListNode*)malloc(sizeof(ListNode)); node->data = x; node->next = NULL; node->prev = NULL; return node; } ListNode*ListCreate() { ListNode*head = (ListNode*)malloc(sizeof(
程序设计基础 OJ 题库 NUIST
10-22
在OJ题库中，常见的数据结构包括数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树等）、哈希表等。理解并熟练运用这些数据结构可以有效地组织和操作数据，实现高效的算法。 在NUIST的"程序设计基础"课程中，...
栈与队列OJ题2
qq_53822523的博客
07-22 136
LeetCode刷题之用栈实现队列、用队列实现栈
栈与队列Oj题
xwy13886467077的博客
09-03 48
解法：关键是push和pop操作，我们可以push时将它全部push到一个队列中，下次push依然push到该队列之中，然后需要pop时，先把前n-1个元素push到另一个队列中，再pop剩余那一个元素，再次pop时依然如此，将这些元素前n-1个元素移动到空队列，再pop剩余那一个。我们将两个栈分为一个pop栈，一个push栈，每次加入元素总是加入push栈中，删除元素总是在pop栈之中，当pop栈为空，那么将push栈元素全部给pop栈即可。压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
【数据结构-Java描述】栈与队列OJ题
qq_36148709的博客
07-28 611
思路准备两个栈，一个栈存放压入的元素，另一个栈存放最小的元素，压栈时，只有当第二个栈为空，或压栈的元素小于第二个栈的栈顶元素时，才往第二个栈里放元素，检索最小元素直接看第二个栈栈顶即可，另外，当出栈时出的元素和第二个栈栈顶元素相同，则要同时出栈，思路准备一个栈，如果是数字，压栈，遇到符号，出栈两个元素，首先出栈的元素放在符号右边，后面出栈的元素放在符号右边，形成一个表达式，计算表达式结果，将值压栈，遍历完成后栈里只剩下一个元素，该元素即为所求值。思路准备两个对，入队操作时，直接入队即可。...
栈和队列OJ题
2302_80105876的博客
05-20 803
如果要用队列实现栈的话，使用一个队列是肯定不行的，队列结构是先进先出，栈结构是先进后出，所以我们要做的就是使用两个队列实现元素的先进后出的功能，要实现出栈操作我们只要，把左边栈的元素逐个导入右边队列中，直到剩下最后一个，再将它取出相当于出队操作。End和Head指向同一位置的时候栈为空的情况，比如原来队列需要的是k个空间，那么我们可以创建k+1个空间，那么我们就可以。用栈实现队列也就是使用栈来实现先进先出的效果，该操作用一个栈是无法完成的，我们考虑用两个栈，栈a用来模拟入队操作，栈b来模拟出队操作。
oj题.zip
10-18
每一道题目都可能包含多种解题策略，如动态规划、贪心算法、回溯、深度优先搜索、广度优先搜索、链表操作、二叉树操作、字符串处理、图论以及基本的数据结构如数组、栈、队列、哈希表等。通过深入研究这些解决方案，...
南阳理工oj离线题库
05-14
2. 数据结构与算法：题库中的题目可能会涉及各种数据结构，如数组、链表、栈、队列、树、图等，以及各种算法，如排序、搜索、动态规划、贪心算法等。用户可以通过解答这些题目来巩固和提升这些基础知识。 3. 编程...
平顶山学院OJ试题离线版
05-14
2. **数据结构**：涉及数组、链表、栈、队列、树（如二叉树、AVL树、红黑树等）、图、哈希表等。掌握这些数据结构能帮助解冑复杂的问题，并优化程序的运行效率。 3. **操作系统**：涵盖进程管理、内存管理、文件...
LeetCode:LeetCode OJ 题库
05-17
这个"LeetCode OJ java题库"包含了多个与Java相关的编程题目，旨在测试和锻炼开发者的编程思维和解决问题的能力。 【描述】：描述中的 "LeetCode OJ java题库242有效图241添加括号的不同方法240搜索2D Matrix II ...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 940
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 233
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 247
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 308
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 533
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 620
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 294
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法题目整合5
qq_62571233的博客
07-23 933
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
贪心加暴力枚举
wniuniu_的博客
07-24 268
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
C++数组实现栈与队列操作详解
本资源是一份C++编程训练营中的代码片段，涉及两个数据结构实现：栈（Stack）和队列（Queue）。首先，我们来看第一个文件`stack.cpp`： 标题："训练营OJ完整版1" 描述："这是关于C++实现一个基于数组的栈（Stack）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值