leetcode 有效括号和循环队列

最新推荐文章于 2024-05-27 19:35:52 发布
最新推荐文章于 2024-05-27 19:35:52 发布
阅读量454 收藏 1
点赞数 8
分类专栏： leetcode 文章标签： 链表 leetcode 数据结构 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Allen9012/article/details/121440663
版权

leetcode 有效括号和循环队列

1. 有效的括号

本题目来源于leetcode有效的括号

1.1 题目描述

image-20211118130216759

提示

image-20211118130242689

1.1.1 接口函数

bool isValid(char * s){

}

1.2 大致框架

虽然数组也可以解决问题但是不太好，后面有些题目就会出现问题 我们尝试用栈来解决问题

直接用c肯定是栈要自己写的，因为没有库，所以如果我们这里要用c语言实现这道题，需要自己写一个栈

1.2.1 想法思路

题目的说输入的情况只有左括号或者右括号,所以我们不用管其他的输入可能性

利用栈的先进后出特性，所以我们可以把是左括号类型（有（{【）的都放入栈中，然后右括号则开始匹配，如果匹配失败，则直接false，如果成功则通过StackPop把栈最上面一个拿掉，然后判断下一个是否匹配，直到最后一个返回true或者中途不匹配返回false

1.2.2 具体步骤

先得c语言自己实现一下栈

声明
#include <stdbool.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef char STDataType ;
struct Stack
{
	STDataType* a;
	int capacity;	//容量，方便增容
	int top;	//栈顶
};

typedef struct Stack Stack;

void StackInit(Stack *pst);
void StackDestroy(Stack* pst);
void StackPush(Stack* pst,STDataType x);
//性质决定了在栈顶数据出入
STDataType StackTop(Stack* pst);
void  StackPop(Stack* pst);

bool StackEmpty(Stack* pst);
int StzckSize(Stack* pst);
函数
void StackInit(Stack* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;

}
void StackDestroy(Stack* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void StackPush(Stack* pst,STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;//容量翻倍
		STDataType* tmp = realloc(pst->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		pst->a = tmp;
		pst->capacity =newCapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}

STDataType StackTop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));
	return pst->a[pst->top - 1];//从高下标往低下标  
}
void StackPop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));

	pst->top--;
}
bool StackEmpty(Stack* pst)
{
	assert(pst);
	return pst->top == 0;//布尔来判断
}

int StzckSize(Stack* pst)
{
	assert(pst);
	return pst->top;//恰好是size
}
然后构建isValid(char * s)

注意事项：

  • 循环里面要由一个分支判断是左括号还是右括号，左括号进栈，右括号判断

  • 不能忘记走完一个分支后s指针要往前继续走

  • 最后如果是空则说明匹配，不空说明不匹配，因为加入最后剩下一个就不判断了会直接返回true，其实应该要false，所以最后应该还是要有一个判断，可以用StackEmpty判断

bool isValid(char * s){
    Stack st;
    StackInit(&st);
    while(*s)
    {
        //左括号入栈
        //右括号找最近的做括号匹配
        if(*s  =='['
           ||*s=='{'
           ||*s=='(')
        {
            StackPush(&st,*s);
            ++s;
        }
        else
        {
              if(StackEmpty(&st))//说明没有前括号
            {
                StackDestroy(&st);
                return false;
            }
            char top=StackTop(&st);
            if((top=='['&&*s!=']')
            ||(top=='('&&*s!=')')
            ||(top=='{'&&*s!='}'))
            {
                StackDestroy(&st);
                return false;
            }
            else
            {
                //匹配的
                StackPop(&st);
                ++s;
            }
        }
    } 
    bool ret=StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}

1.3 整体实现

#include <stdbool.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef char STDataType;
struct Stack
{
	STDataType* a;
	int capacity;	//容量，方便增容
	int top;	//栈顶
};

typedef struct Stack Stack;

void StackInit(Stack *pst);
void StackDestroy(Stack* pst);
void StackPush(Stack* pst,STDataType x);
//性质决定了在栈顶数据出入
STDataType StackTop(Stack* pst);
void  StackPop(Stack* pst);
bool StackEmpty(Stack* pst);
void StackInit(Stack* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;

}
void StackDestroy(Stack* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void StackPush(Stack* pst,STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;//容量翻倍
		STDataType* tmp = realloc(pst->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		pst->a = tmp;
		pst->capacity =newCapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}

STDataType StackTop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));
	return pst->a[pst->top - 1];//从高下标往低下标  
}
void StackPop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));

	pst->top--;
}
bool StackEmpty(Stack* pst)
{
	assert(pst);
	return pst->top == 0;//布尔来判断
}

bool isValid(char * s){
    Stack st;
    StackInit(&st);
    while(*s)
    {
        //左括号入栈
        //右括号找最近的做括号匹配
        if(*s  =='['
           ||*s=='{'
           ||*s=='(')
        {
            StackPush(&st,*s);
            ++s;
        }
        else
        {
              if(StackEmpty(&st))//说明没有前括号
            {
                StackDestroy(&st);
                return false;
            }
            char top=StackTop(&st);
            if((top=='['&&*s!=']')
            ||(top=='('&&*s!=')')
            ||(top=='{'&&*s!='}'))
            {
                StackDestroy(&st);
                return false;
            }
            else
            {
                //匹配的
                StackPop(&st);
                ++s;
            }
        }
    } 
    bool ret=StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}

小结：

这道题目用c++的话会简单很多，因为可以直接调接口，但是c语言就得自己实现一个栈，会比较麻烦

2. 设计循环队列

本题目来源于leetcode 622. 设计循环队列

这道题目涉及到的可能会深一点，难度会高一点

2.1 题目描述

image-20211120134659327提示

image-20211120134716384

2.1.1 接口函数

typedef struct {

} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {

}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {

}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {

}

int myCircularQueueFront(MyCircularQueue* obj) {

}

int myCircularQueueRear(MyCircularQueue* obj) {

}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {

}

bool myCircularQueueIsFull(MyCircularQueue* obj) {

}

void myCircularQueueFree(MyCircularQueue* obj) {

}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

2.2 大致框架

2.2.1 想法思路

用数组或链表实现

要实现循环队列肯定是得用到循环链表了，不能光单链表不是吗,当然数组也可以，链表的话更像是一个环

按照题目的意思我们要实现的功能是能使用之前用过的空间，要求队列满了不能再插入，但是没满或者满了再删了之后，我们可以用之前的位置存放数据

image-20211120143423777

解决空和满

要想完成这样一个题目的要求是不是我们要有两个指针

image-20211120144106592

但是这个想法的话是无法判断这个循环队列里面是空还是满的

所以要区分两种情况，什么时候判定算满，什么时候判定算空

这里采取空出一个位置不存数据来解决，比如说这个队列4个数据就满，则我只存3个那么这时可以判断了

  • 以下的图例上方的是链表，下方演示的是数组
  1. 满就``tail->next为front`
    image-20211120140431728
  2. 空就tail==front

image-20211120140812660

那么此时我们也能实现pop和push操作

小结：

我们一般什么时候会用到这个循环队列呢？

比如说操作系统中的生产者和消费者问题

image-20211120144554348

2.2.2 具体步骤

我们用数组实现一下,因为数组比链表可能实现的简单一点

注意以下步骤实现的函数仍有问题，后面会在找报错问题时解决，整体实现里是正确的代码

myCircularQueueCreate

typedef struct {
int * a;
int k;//队列最多能存多少个数据
int front;  //头
int tail;  //尾（队尾数据的下一个）
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
 MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
 obj->a=(int*)malloc(sizeof(int)*(k+1));//留一个
 obj->front=0;
 obj->tail=0;
 obj->k=k;
 return obj;
}

myCircularQueueIsEmpty

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->front==obj->tail;
}

myCircularQueueIsFull

bool myCircularQueueIsFull(MyCircularQueue* obj) {
	int tailNext = obj->tail + 1;
	if (tailNext == obj->k + 1)//防止next走出去
	{
		tailNext = 0;
	}
	return tailNext == obj->front;
}

myCircularQueueEnQueue

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	if (myCircularQueueIsFull(obj))
	{
		return false;
	}
	else
	{
		obj->a[obj->tail] = value;
		++obj->tail;
		if (obj->tail == obj->k + 1)
		{
			obj->tail = 0;
		}
		return true;
	}
}

myCircularQueueDeQueue

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

myCircularQueueFront

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

myCircularQueueRear

int myCircularQueueRear(MyCircularQueue* obj) {
	int tailPrev = obj->tail - 1;
	if (tailPrev == -1)//防止prev走出去
	{
		tailPrev = obj->k;
	}
	return obj->a[tailPrev];
}

myCircularQueueFree

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

2.2.3 寻找报错问题

image-20211120153411577

说明问题出在Front上，按照值钱的输入的话，在执行这个Front之前这个循环队列里面是没有数据的，所以返回的Front应该是空的，所以说明这个点没有考虑到，如果为空返回-1即可

myCircularQueueFront

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

那么myCircularQueueRear应该也是一样，虽然没有提示但是可以想到

int myCircularQueueRear(MyCircularQueue* obj) {
	int tailPrev = obj->tail - 1;
	if (tailPrev == -1)//防止prev走出去
	{
		tailPrev = obj->k;
	}
 if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
      return obj->a[tailPrev];
    }
}

2.3 整体实现

#include<stdbool.h>
typedef struct {
	int* a;
	int k;//队列最多能存多少个数据
	int front;  //头
	int tail;  //尾（队尾数据的下一个）
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
	MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	obj->a = (int*)malloc(sizeof(int) * (k + 1));//留一个
	obj->front = 0;
	obj->tail = 0;
	obj->k = k;
	return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
	return obj->front == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
	int tailNext = obj->tail + 1;
	if (tailNext == obj->k + 1)//防止next走出去
	{
		tailNext = 0;
	}

	return tailNext == obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	if (myCircularQueueIsFull(obj))
	{
		return false;
	}
	else
	{
		obj->a[obj->tail] = value;
		++obj->tail;
		if (obj->tail == obj->k + 1)
		{
			obj->tail = 0;
		}
		return true;
	}
}

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

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

int myCircularQueueRear(MyCircularQueue* obj) {
	int tailPrev = obj->tail - 1;
	if (tailPrev == -1)//防止prev走出去
	{
		tailPrev = obj->k;
	}
	if (myCircularQueueIsEmpty(obj))
	{
		return -1;
	}
	else
	{
		return obj->a[tailPrev];
	}
}

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

image-20211120154607723

小结：

栈和队列的难点主要在于结构复杂，不在于单个逻辑，写多了就会感觉好多了

后面更难的栈和队列的题目之后会使用c++的stl库再实现

如果老铁们有收获的话，希望给个一键三连哦，谢谢

言之命至9012
关注
  • 8
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
leetcode 括号组合
weixin_46521165的博客
06-28 463
题目 给定整数nnn，给出所有nnn对括号的有效的组合，例如：给定n=3n=3n=3 输出： （（（））） （（）（）） （（））（） （）（（）） （）（）（） 分析思路 给定nnn，输出的字符长度为2∗n2*n2∗n 每个位置有2种情况，那么不考虑是否有效，则有22∗n2^{2*n}22∗n种情况。 那么从第一个位置开始考虑，开始往后判断每一个位置的2种情况，如果满足继续，如果不满足则终止。 可以想到，这其实就是构建一个二叉树，通过判断二叉树的分支是否合理，最终返回全部深度为nnn的分支。 参考上一小节
LeetCode判断字符串是否循环-Queue_Stack:依赖数组实现栈，实现链式队列，实现循环队列，两个栈实现一个队列，两个队列实现一个栈
07-01
LeetCode判断字符串是否循环 1、实现链式队列 特点：先进先出 定义Node类，存放队列的data，next 定义Node类的front（头结点），rear（尾结点），int类型的usesize（队列的大小） 定义front和rear的原因： 采用头插...
LeetCode 有效括号
毛毛毛小新的博客
02-25 915
给定一个只包括 '('，')'，'{'，'}'，'['，']'的字符串 s ，判断字符串是否有效。 有效字符串需满足：左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 解决方法：有效括号可采用栈的原理。遍历字符串，对于左括号入栈，遇到右括号，则将栈顶匀速弹出，如果两括号刚好匹配，则为有效字符。 代码实现： class Solution { public boolean isValid(String s) { if(s.length()==0){ .
LeetCode栈和队列经典例题
m0_70811813的博客
01-09 693
这里有四道关于栈和队列的经典题型
[leetcode622]设计循环队列
Abider2的博客
06-02 189
循环队列
【Leetcode】循环队列实现和括号匹配问题
来杯茶_要绿的的博客
04-30 184
循环队列实现和括号匹配问题
Leetcode 题解 - 栈和队列
Stay Hungry, Stay Foolish!
02-24 176
文章目录1. 用栈实现队列2. 用队列实现栈3. 最小值栈4. 有效的括号5. 每日温度6. 下一个更大元素 II7. 柱状图中最大的矩形8. 接雨水 1. 用栈实现队列 232. Implement Queue using Stacks (Easy) Leetcode / 力扣 栈的顺序为后进先出，而队列的顺序为先进先出。使用两个栈实现队列，一个元素需要经过两个栈才能出队列，在经过第一个栈时元素顺序被反转，经过第二个栈时再次被反转，此时就是先进先出顺序。 public class MyQueue {
LeetCode实战：设计循环双端队列
老马的程序人生
08-18 743
题目英文 Design your implementation of the circular double-ended queue (deque). Your implementation should support following operations: MyCircularDeque(k): Constructor, set the size of the deque to be k...
leetcode栈和队列的相关题、有效的括号、用队列实现栈、用栈实现队列、设计循环队列等介绍
最新发布
Farewell_me的博客
05-27 670
leetcode栈和队列的相关题、有效的括号、用队列实现栈、用栈实现队列、设计循环队列等介绍leetcode栈和队列的相关题、有效的括号、用队列实现栈、用栈实现队列、设计循环队列等介绍leetcode有效的括号leetcode用队列实现栈leetcode用栈实现队列leetcode设计循环队列。
leetcode刷题/栈和队列 20. 有效的括号
公仔面
07-21 76
20. 有效的括号 题意: 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 1.左括号必须用相同类型的右括号闭合。 2.左括号必须以正确的顺序闭合。 示例 1： 输入：s = "()" 输出：true 示例 2： 输入：s = "()[]{}" 输出：true 示例 3： 输入：s = "(]" 输出：false 示例 4： 输入：s = "([)]" 输出：false 示例 5： 输入：s = "{[]}" 输出：tru
leetcode苹果-leetcode:数据结构和算法
06-30
leetcode 苹果 leetcode 20200811 项目结构 leetcode-comm 公共类 练习题 1：链表 206. 反转链表 141. 环形链表 21. 合并两个有序链表 ...有效的括号 ...实现一个循环队列 4：排序算法 冒泡排序 插入排序 选
leetcode530-leetcode:leetcode
06-30
实现二叉搜索树，循环队列 2021-05-18: 226二叉树翻转 2021-05-19: 450 删除二叉树节点 700 二叉搜索树中的搜索 701 二叉搜索树种的插入操作 98 验证二叉搜索树 530 二叉搜索树中的最小绝对差 783 二叉搜索树节点...
learn-leetcode
03-15
学习LeetCode相关知识指南最佳平台，可帮助您增强技能...寻找两个正序分段的中位数来自主题（） [0]队列-实施-循环队列[0]堆栈-实现-最小堆栈2021-03-12 由面试（） [1]两数之和来自主题（） [0]队列-实施[0]堆栈-实现
leetcode添加元素使和等于-Play-with-Data-Structures:玩转数据结构
06-30
数组队列和循环队列的比较 补充代码1: 不浪费一个空间的循环队列 补充代码2: 没有size成员变量的循环队列 第四章 最基础的动态数据结构：链表 4-1 什么是链表 4-2 在链表中添加元素 4-3 使用链表的虚拟头结点 4-4 ...
leetcode添加元素使和等于-Play-With-Data-Structures:慕课网学习
06-30
leetcode添加元素使和等于 ...数组队列和循环队列的比较 补充代码1: 没有size成员变量的循环队列 [整理中，敬请期待] 第四章 最基础的动态数据结构：链表 4-1 什么是链表 4-2 在链表中添加元素 4-3 使用链
LeetCode判断字符串是否循环-Data-Structures-and-Algorithms:记录学习数据结构与算法的笔记
07-01
有效的括号 155: 最小栈 232: 用栈实现队列(todo) 844: 比较含退格的字符串 224: 基本计算器 682: 棒球比赛 496: 下一个更大的元素 503: 下一个更大的元素(循环数组) todo 1118 dp 递归： n叉树的遍历 数组迭代 题目...
leetcode答案-algorithm_problem_solving:CTCI书籍和Leetcode问题的解决方案
06-30
答案CTCI书籍和Leetcode问题的解决方案 类别 名称 问题 回答 笔记 个人评分 细绳 是独特的 CTCI 1-1 + 细绳 检查排列 CTCI 1-2 + :star: 细绳 网址化 CTCI 1-3 + 细绳 Penidrom 排列 CTCI 1-4 —— :star: 细绳 一走...
javalruleetcode-LeetCode:LeetCode第一遍刷题记录
06-29
java lru leetcode Java 中的 LeetCode 解决方案 线性列表 大批 从排序数组中删除重复项 从排序数组中删除重复项 ...二和 ...3和最近 ...有效数独 ...链表循环 ...有效回文 ...有效号码 ...有效字谜 ...最长有效括号 直方图中最
LeetCode题目循环语句
03-21
有很多 LeetCode 题目需要使用循环语句来解决，比如遍历数组、链表等数据结构，或者进行计数、累加等操作...在编写循环语句时，需要注意循环条件的正确性和循环体内部的逻辑正确性，避免出现死循环或者逻辑错误的情况。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

言之命至9012

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值