【Leetcode】栈的性质与应用

已于 2023-03-26 20:34:46 修改
阅读量290 收藏 2
点赞数 6
分类专栏： 数据结构 C语言 文章标签： leetcode 数据结构 c语言
于 2023-03-26 20:32:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73614724/article/details/129783364
版权

文章目录

20. 有效的括号

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。

左括号必须以正确的顺序闭合。

每个右括号都有一个对应的相同类型的左括号。

示例1：

输入： s = " ( ) "
输出：true

示例2：

输入： s = " ( ) [ ] { } "
输出： true

示例3：

输入： s = " ( ] "
输出： false

提示

· 1 <= s.length <= 10 ^ 4
· s 仅由括号 ‘ () [ ] { } ’ 组成

bool isValid (char* s){
}

分析：

这道题可以用栈来写，但是目前还未学习C++，所以只能先手撕一个栈。

如果是左括号，进栈；如果是右括号，出栈里的左括号，进行匹配，匹配失败返回false。

题解：

//栈的操作
#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<malloc.h>
#include<stdlib.h>

typedef int STDataType;
#define CAPACITY 4

typedef struct Stack {
	int* s;
	int top;
	int capacity;
}ST;

void STInit(ST* ps);//栈的初始化
void STDestroy(ST* ps);//栈的销毁
bool STEmpty(ST* ps);//判断栈是否为空
void STPush(ST* ps, STDataType x);//进行插入数据
void STPop(ST* ps);//删除数据
STDataType STTop(ST* ps);//寻找栈顶的数据
int STSize(ST* ps);//查看栈有几个元素


void STInit(ST* ps)
{
	assert(ps);//栈不能为空
	ps->s = (STDataType*)malloc(sizeof(STDataType) * CAPACITY);//malloc开辟空间
	if (ps->s == NULL)
	{
		perror("malloc fail");//开辟失败报错
		return;
	}
	ps->top = 0;//将top置为0，代表数据的个数。赋值为多少无所谓，看个人习惯
	ps->capacity = CAPACITY;//将容量先置为空
}

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

void STDestroy(ST* ps)
{
	assert(ps);

	free(ps->s);//释放空间
	ps->s = NULL;//同时将指针置为空
    ps->top = 0;
    ps->capacity = 0;
}

void STPush(ST* ps, STDataType x)
{
	assert(ps);
	//要先检查容量，判断为不为满，满了进行扩容
	//如果扩容步骤使用很多次，就可以写个扩容函数，只有一次就没必要
	if (ps->top == ps->capacity)
	{
		STDataType* new = (STDataType*)realloc(ps->s, sizeof(STDataType) * ps->capacity * 2);
		if (new == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->s = new;
		ps->capacity *= 2;
	}
	ps->s[ps->top] = x;
	ps->top++;
}

void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));//如果栈为空的话，就不能进行删除
	ps->top--;//直接将个数减一就行了
}

STDataType STTop(ST* ps)
{
	assert(ps);
    assert(!STEmpty(ps));
	return ps->s[ps->top - 1];//返回元素减一的数据
}

int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//申请了动态空间要返回操作系统
//思路：遇到左括号就进栈，遇到右括号进行出栈匹配，若匹配失败返回false，直至字符指针指向空
bool isValid(char * s){
    ST st;
    STInit(&st);
    
    while (*s)
    {
        //遇到左括号进栈
        if (*s == '('
         || *s == '['
         || *s == '{')
         {
             STPush(&st, *s);
         }
         //遇到右括号出栈
        else
        {
            //如果第一个符号为右括号则直接返回false
            if (STEmpty(&st))
            {
                STDestroy(&st);
                return false;
            }
            //栈顶元素与右括号进行匹配
            if ((STTop(&st) != '(' && *s == ')')
              ||(STTop(&st) != '[' && *s == ']')
              ||(STTop(&st) != '{' && *s == '}'))
              {
                  STDestroy(&st);
                  return false;
              }
              //匹配成功就要删除栈顶元素，指向下一个元素
            STPop(&st);
           
        }
        s++;
    }  
    //如果只有一个左括号，就要判断栈里面是否为空，判空函数类型为bool类型
    //为空返回true，正好是正确的
    //不为空返回false，是错误的
    bool ret = STEmpty(&st);
    STDestroy(&st);
    return ret;

232. 用栈实现队列

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

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾

int pop() 从队列的开头移除并返回元素

int peek() 返回队列开头的元素

boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。

你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可

示例1：

输入：
[“MyQueue”, “push”, “push”, “peek”, “pop”, “empty”]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]
解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

1 <= x <= 9

最多调用 100 次 push、pop、peek 和 empty

假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

分析：

队列的性质是先进先出，栈的性质是后进先出，所以利用两个栈来实现队列的性质就可以了。例子：如果插入数据1 2 3 4，输出数据1 2 3 4，如何使栈实现这样的操作呢？
我们可以1 2 3 4存入到一个栈中，当要出数据时，存入另一个栈中，两个栈分别作为入栈和出栈的功能。
在这里插入图片描述

题解：

#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<malloc.h>
#include<stdlib.h>

typedef int STDataType;
#define CAPACITY 4

typedef struct Stack {
	int* s;
	int top;
	int capacity;
}ST;

void STInit(ST* ps);//栈的初始化
void STDestroy(ST* ps);//栈的销毁
bool STEmpty(ST* ps);//判断栈是否为空
void STPush(ST* ps, STDataType x);//进行插入数据
void STPop(ST* ps);//删除数据
STDataType STTop(ST* ps);//寻找栈顶的数据
int STSize(ST* ps);//查看栈有几个元素

void STInit(ST* ps)
{
	assert(ps);//栈不能为空
	ps->s = (STDataType*)malloc(sizeof(STDataType) * CAPACITY);//malloc开辟空间
	if (ps->s == NULL)
	{
		perror("malloc fail");//开辟失败报错
		return;
	}
	ps->top = 0;//将top置为0，代表数据的个数。赋值为多少无所谓，看个人习惯
	ps->capacity = CAPACITY;//将容量先置为空
}

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

void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->s);//释放空间
	ps->s = NULL;//同时将指针置为空
	ps->top = 0;
	ps->capacity = 0;
}

void STPush(ST* ps, STDataType x)
{
	assert(ps);
	//要先检查容量，判断为不为满，满了进行扩容
	//如果扩容步骤使用很多次，就可以写个扩容函数，只有一次就没必要
	if (ps->top == ps->capacity)
	{
		STDataType* new = (STDataType*)realloc(ps->s, sizeof(STDataType) * ps->capacity * 2);
		if (new == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->s = new;
		ps->capacity *= 2;
        
	}
	ps->s[ps->top] = x;
	ps->top++;
}

void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));//如果栈为空的话，就不能进行删除
	ps->top--;//直接将个数减一就行了
}

STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->s[ps->top - 1];//返回元素减一的数据
}

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

typedef struct {
    ST emptyst;
    ST nonemptyst;
} MyQueue;

//队列的初始化
MyQueue* myQueueCreate() {
    MyQueue* newQueue = (MyQueue*)malloc(sizeof(MyQueue));
    if (newQueue == NULL)
    {
        perror("malloc fail");
        return NULL;
    }
    //对栈进行初始化
    STInit(&newQueue->emptyst);
    STInit(&newQueue->nonemptyst);
    return newQueue;
}
//固定一个栈插入数据
void myQueuePush(MyQueue* obj, int x) {

        STPush(&obj->nonemptyst, x);
    
}

int myQueuePop(MyQueue* obj) {
    //如果出数据的栈为空，那么就要移除数据
    if (STEmpty(&obj->emptyst))//不加这个条件就会顺序混乱
    {
         while (STSize(&obj->nonemptyst))
        {
            STPush(&obj->emptyst, STTop(&obj->nonemptyst));
            STPop(&obj->nonemptyst);
        }
    }
   //不为空，直接出栈
    int top = STTop(&obj->emptyst);
    STPop(&obj->emptyst);
    return top;
}

int myQueuePeek(MyQueue* obj) {
    //出数据的栈为空，那么就要进行移数据
    if (STEmpty(&obj->emptyst))
    {
        while (STSize(&obj->nonemptyst))
        {
            STPush(&obj->emptyst, STTop(&obj->nonemptyst));
            STPop(&obj->nonemptyst);
        }
    }
    
    return STTop(&obj->emptyst);
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->emptyst) && STEmpty(&obj->nonemptyst);
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->emptyst);
    STDestroy(&obj->nonemptyst);
    free(obj);
}

/**
 * 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);
*/
时间的光线
关注
  • 6
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
leetcode
03-28
3. 栈与队列：掌握它们的基本性质和应用场景，如括号匹配、深度优先搜索（DFS）和广度优先搜索（BFS）。 4. 树结构：二叉树、平衡树（AVL、红黑树）等，用于解决递归和层次遍历的问题。 5. 哈希表：通过哈希映射快速...
Leetcode.rar
04-02
《LeetCode解题心得与技巧探索》 在编程领域，LeetCode无疑是一个备受推崇的在线平台，它提供了海量的编程题目，旨在提升开发者的问题解决能力和算法思维。本压缩包“Leetcode.rar”收录了我在LeetCode上挑战的前十...
单调栈详解及其LeetCode应用详解
Steve Wang's blog
12-12 315
**栈(Stack)是一种操作受限的线性表，只允许一端进，同一端出，因而具有后进先出(LIFO)**的特性。
leetcode_单调栈篇
qq_40088655的博客
07-22 231
单调栈的应用情况以及相关题目讲解: )
LeetCode题解栈与队列篇（TS版）
Leon_Chenl的博客
05-27 421
优先级队列是一种抽象数据类型，它类似于一个常规的队列或栈数据结构，但每个元素都有一定的关联优先级。在堆的实现中，元素可以在O(1)时间内获取（查看）最大/最小元素，而删除最大元素和插入新元素则需要O(log n)的时间。其中，n是队列中的元素数量。输入: [“10”, “6”, “9”, “3”, “+”, “-11”, " * ", “/”, " * ", “17”, “+”, “5”, “+”]给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串，判断字符串是否有效。
【Leetcode】栈-20
⛄
01-13 231
题目： 输入输出： 解题思路： 算法实现： 出现问题：
leetcode学习——栈和对列
qq_50714222的博客
10-27 202
​ 开始在leetcode上刷栈和对列相关题目了，同时整理一些栈和对列的相关知识点。主要跟着代码随想录学习，大家也可以参考该博主的内容【附各种语言的代码，解释也很详细】。对于我而言，相当于秉持着【学有留痕】的原则做一个学习上的记录，方面自己以后回顾相关知识点。祝看到文章的小伙伴们都学有所成！ 对不同类型的堆和栈的具体使用，尤其是性质和函数还在继续，后面会继续补充该部分的内容。 ​
单调栈的应用——接雨水
can_chen的博客
12-24 659
题目描述 LeetCode 42. 接雨水（难度：困难） 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 解题思路： 首先，拿到这道题目的时候，我们应该先想，什么情况下才能接到雨水？如果凭空想象会很难，但是结合题目给出的图解就非常清晰了，如果后面的柱子高度比前面的柱子高度小，那么是接不到雨水的，而如果后面的柱子高度是大于前面柱子高度的，那么是有可能接到雨水的（注意只是有可能，后面我们就可以看出接不到雨水的情形），想到这一步，就可以把这道题转换一下.
栈与队列——图示分析+习题应用！
wyr1849089774的博客
01-20 255
栈与队列在数据结构中占据很重要的地位，在今天的学习中我们要初步掌握栈与队列的基本性质以及相关的容器操作，除此之外大家也要对栈与队列的底层实现多加了解。
[日记]LeetCode算法·三——栈与队列
Leafing_的博客
02-16 90
数据结构与算法，栈与队列
栈、单调栈的应用与实践
miaohan981208的博客
08-10 189
分类 链栈 & 顺序栈 普通栈 & 单调栈 满栈 & 空栈 单调栈 单调栈是一种拥有特殊的栈性质的数据结构，分为单调递减栈和单调递增栈两种类型， 单调递增栈：单调递增栈就是从栈底到栈顶数据是从大到小 单调递减栈：单调递减栈就是从栈底到栈顶数据是从小到大 单调栈的一般压栈弹栈逻辑： 以单调递减栈为例，当栈为空时直接进行压栈，当单调栈不为空时，为保证单调栈的单调性不变，当压入值小于栈顶元素时需先对栈顶元素进行弹栈操作之后再进行压栈。 逻辑作用： 平时使用时单调
Leetcode刷题（20）栈和队列的基本应用：用队列实现栈
01-20
题目分析： 这题主要考察对于栈和队列性质的理解，他们的本质不同就在于元素进入和弹出的顺序，完全相反。栈是 Last In First Out (LIFO), 队列是 Fisrt In First Out (FIFO), 实现起来有点变扭。 解法： class ...
Leet:Leetcode
03-27
通过 "Leet:Leetcode" 提供的 Java 解决方案，学习者可以深入理解这些算法和数据结构的实际应用，同时提高编程能力，为面试做好充分准备。每个问题都伴随着详细的解释和代码，便于理解和学习。对于希望在 IT 领域...
Leetcode-Solutions:解决leetcode问题
03-19
3. 树和图：二叉树、平衡树（如AVL、红黑树）以及图的遍历算法（深度优先、广度优先）是LeetCode上的常见题型，熟悉它们的性质和操作至关重要。 4. 哈希表和集合：哈希表提供快速查找功能，而集合可以方便地进行...
LEETCODE100热题双指针
m0_74484354的博客
07-15 94
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
力扣224.基本计算器
Pisasama的博客
07-14 232
【代码】力扣224.基本计算器。
1. LeetCode-数组和字符串
最新发布
weixin_43149506的博客
07-18 586
数组和字符串介绍以及相关例题
力扣1111.有效括号的嵌套深度
Pisasama的博客
07-14 346
对于。
leetcode 栈
07-30
引用\[2\]提供了另一个栈的应用场景，即判断括号是否有效。遍历字符串，如果是左括号则压入栈，如果是右括号则判断和栈顶元素是否匹配，不匹配则返回false，匹配则弹出栈顶元素。最后判断栈是否为空即可判断括号是否...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值