【数据结构】LeetCode栈和队列经典题型

已于 2022-05-17 18:36:24 修改
阅读量963 收藏 14
点赞数 18
分类专栏： 数据结构 文章标签： 数据结构 leetcode c++
于 2022-05-17 18:29:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56653788/article/details/124825313
版权

目录

1.有效的括号

 2.用队列实现栈​编辑

3.用栈实现队列​编辑

4.设计循环队列

1.有效的括号

思路：因为左括号要和右括号顺序和类型都匹配，那么当从第一个右括号开始就要和左括号里最后一个匹配，如果匹配就下一个继续往后走。这样我们非常容易想到栈，左括号入栈，当遇到右括号就出栈，然后判断是否匹配，若不匹配就返回false，匹配就看下一个，直到栈为空。

代码：因为这里是C语言实现所有需要创建栈来使用，就用前面讲过的栈来用

typedef char STDataType;

//栈必须符合后进先出的原则
//创建动态栈空间
typedef struct Stack
{
	STDataType* val;
	int top;//栈顶
	int capacity;//栈容量
}ST;

//初始化
void StackInit(ST* ps);
//销毁栈空间
void StackDestroy(ST* ps);
//插入数据
void StackPush(ST* ps,STDataType x);
//删除数据
void StackPop(ST* ps);
//拿出栈顶的数据
STDataType StackTop(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);
//计算栈的长度
int StackSize(ST* ps);

//初始化
void StackInit(ST* ps)
{
	assert(ps);
	ps->val = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

//销毁栈空间
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->val);
	ps->val = NULL;
	ps->top = ps->capacity = 0;
}

//插入数据
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//先看空间够不够
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->val,sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc");
			return;
		}
		ps->val = tmp;
		ps->capacity = newCapacity;
	}
	//栈顶的数据元素给值
	ps->val[ps->top] = x;
	++ps->top;
}

//删除数据
void StackPop(ST* ps)
{
	assert(ps);
	//判断栈是否为空
	assert(!StackEmpty(ps));

	--ps->top;
}

//找到栈顶的数据
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->val[ps->top-1];
}

//判断栈是否为空
bool StackEmpty(ST* ps)
{
    assert(ps);

    return ps->top == 0;
}

//计算栈的长度
int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

bool isValid(char * s){
    ST st;
    StackInit(&st);
    while(*s)
    {
        if(*s == '(' || *s == '{' || *s == '[')
        {
            StackPush(&st,*s);
            ++s;
        }
        else
        {
            //在判断右括号之前如果栈里没有东西也返回false
            if(StackEmpty(&st))
            {

                StackDestroy(&st);
                return false;
            }
            //比较
            STDataType top = StackTop(&st);
            StackPop(&st);
            if((top == '(' && *s == ')')
            || (top == '{' && *s == '}')
            || (top == '[' && *s == ']'))
            {
                ++s;
            }
            else
            {
                //销毁空间返回false
                StackDestroy(&st);
                return false;
            }
        }
    }
    //如果出来了判断栈是否为空，如果为空的话就代表全部匹配
    bool ret = StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}

 2.用队列实现栈

 思路：用两个队列来实现后进先出的队列。插入数据时，需要往不为空的队列里插入。删除时需要倒数据，返回栈顶也就是返回队列的尾，判断栈是否为空只需判断两个队列是否为空。下图是移除并返回栈顶元素的思路。

 代码：

typedef int QDatatype;

//用链表实现队列
typedef struct QueueNode
{
	QDatatype val;
	struct QueueNode* next;
}QNode;

//存放链表的头结点和尾结点
typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq,QDatatype x);
void QueuePop(Queue* pq);
QDatatype QueueFront(Queue* pq);
QDatatype QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDatatype x)
{
	assert(pq);
	//创建一个新结点
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		return;
	}
	newnode->val = x;
	newnode->next = NULL;
	//队列为空的创建
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	//队列不为空的创建
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

void QueuePop(Queue* pq)
{
	assert(pq);

	//判断当前队列是否为空
	assert(!QueueEmpty(pq));

	//若队列中只有一个结点
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	//不止一个结点
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

}

QDatatype QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->val;
}

QDatatype QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->val;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);

	//只用判断头是否为空就行
	return pq->head == NULL;
}

int QueueSize(Queue* pq)
{
	int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		++size;
		cur = cur->next;
	}
	return size;
}

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

MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    //初始化
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    //返回obj的地址
    return obj;
}

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

int myStackPop(MyStack* obj) {
    //讲有数据的倒到空的队列里，留一个然后删除留的那一个
    //首先假设q1为空，q2不为空
    //找到空的和不空的队列
    Queue* empty = &obj->q1;
    Queue* notempty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty = &obj->q2;
        notempty = &obj->q1;
    }

    //倒数据
    int size = QueueSize(notempty);
    while(size>1)
    {
        //插入到空的队列中去
        QueuePush(empty,QueueFront(notempty));
        QueuePop(notempty);
        size--;
    }
    //先传给top再删除最后剩下的这个数据
    int top = QueueFront(notempty);
    QueuePop(notempty);
    return top;
}

int myStackTop(MyStack* obj) {
    //只需要返回，不用删除，可以不用倒，直接找非空的最后一个数
    Queue* empty = &obj->q1;
    Queue* notempty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty = &obj->q2;
        notempty = &obj->q1;
    }
    int top = QueueBack(notempty);
    return top;
}

bool myStackEmpty(MyStack* obj) {

    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    //先释放两个队列
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    //再释放obj
    free(obj);
}

3.用栈实现队列

 思路：上面一题的数据需要在队列之间来回倒，这里不需要，因为队列是后进先出的，当我们将栈1的数据倒到栈2里时栈2里的数据就是逆序，若要删除只需从栈顶依次删除下来，符合队列的先进先出规则，插入数据时需要注意的是，我们一个栈只入栈，一个栈只出，只往栈1里入栈，栈2只出，当栈2有数据时就不能倒，为空时才能倒。

 代码：

typedef char STDataType;

//栈必须符合后进先出的原则
//创建动态栈空间
typedef struct Stack
{
	STDataType* val;
	int top;//栈顶
	int capacity;//栈容量
}ST;

//初始化
void StackInit(ST* ps);
//销毁栈空间
void StackDestroy(ST* ps);
//插入数据
void StackPush(ST* ps,STDataType x);
//删除数据
void StackPop(ST* ps);
//拿出栈顶的数据
STDataType StackTop(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);
//计算栈的长度
int StackSize(ST* ps);

//初始化
void StackInit(ST* ps)
{
	assert(ps);
	ps->val = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

//销毁栈空间
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->val);
	ps->val = NULL;
	ps->top = ps->capacity = 0;
}

//插入数据
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//先看空间够不够
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->val,sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			return;
		}
		ps->val = tmp;
		ps->capacity = newCapacity;
	}
	//栈顶的数据元素给值
	ps->val[ps->top] = x;
	ps->top++;
}

//删除数据
void StackPop(ST* ps)
{
	assert(&ps);
	//判断栈是否为空
	assert(!StackEmpty(ps));

	ps->top--;
}

//拿出栈顶的数据
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->val[ps->top-1];
}

//判断栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

//计算栈的长度
int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}


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


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));

    StackInit(&obj->s1);
    StackInit(&obj->s2);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    //默认s1栈专门进队列，s2专门出队列
    StackPush(&obj->s1,x);
}

int myQueuePop(MyQueue* obj) {
    //s2为空时，将s1的数据倒入s2中
    if(StackEmpty(&obj->s2))
    {
        //栈底的数据留着直接返回并删除就行
        while(StackSize(&obj->s1)>1)
        {
            StackPush(&obj->s2,StackTop(&obj->s1));
            StackPop(&obj->s1);
        }
        int top = StackTop(&obj->s1);
        StackPop(&obj->s1);
        return top;
    }
    //s2不为空时从s2栈顶开始取数据
    else
    {
        int top = StackTop(&obj->s2);
        StackPop(&obj->s2);
        return top;
    }
}

int myQueuePeek(MyQueue* obj) {
    //若s2为空时，将s1的数据全部倒入s2中
    if(StackEmpty(&obj->s2))
    {
        //将全部s1倒入s2
        while(StackSize(&obj->s1))
        {
            StackPush(&obj->s2,StackTop(&obj->s1));
            StackPop(&obj->s1);
        }
    }
    //返回s2的栈顶
    int top = StackTop(&obj->s2);
    return top;
}

bool myQueueEmpty(MyQueue* obj) {

    return StackEmpty(&obj->s1) && StackEmpty(&obj->s2);
}

void myQueueFree(MyQueue* obj) {

    StackDestroy(&obj->s1);
    StackDestroy(&obj->s2);
    free(obj);
}

4.设计循环队列

思路： 当队列为循环状态时，我们头空的情况下头等于尾，那么当我们满的情况下呢？头还等于尾吗？于是我们设计了下面这个

这里我们用数组来实现较为简单 把上面那个圆展开就成了一个数组。

当插入数据时插入在tail位置，然后tail++，不过每次插入时需要判断是否已满，删除数据时将head向后移即可删除。不过需要注意的是当在边界时我们需要处理tail和head。

代码：

//用数组实现
typedef struct {
    int* a;
    int k;
    int head;
    int tail;
} MyCircularQueue;

//函数声明
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    obj->k = k;
    obj->head = obj->tail = 0;

    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //首先判断是否满了
    if(myCircularQueueIsFull(obj))
        return false;
    
    obj->a[obj->tail] = value;
    obj->tail++;
    
    //特殊处理，当tail>k时
    if(obj->tail == obj->k+1)
        obj->tail = 0;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //判断是否为空
    if(myCircularQueueIsEmpty(obj))
        return false;
    
    //将head向后移
    obj->head++;

    //当head在最后一位时需要特殊处理
    if(obj->head == obj->k+1)
        obj->head = 0;
    return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    
    //当tail为0时返回队尾的数
    if(obj->tail == 0)
        return obj->a[obj->k];
    //返回tail前面的数据
    else
        return obj->a[obj->tail-1];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    //当head=tail时为空
    return obj->head == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    //如果tail在head前一个就说明满了
    int head = obj->head;
    int tail = obj->tail + 1
    ;
    //当tail在队尾时处理一下
    if(tail == obj->k+1)
        tail = 0;
    if(head == tail)
        return true;
    else
        return false;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    //先释放数组
    free(obj->a);
    //再释放结构体
    free(obj);
}

Iceevov
关注
  • 18
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 19
    评论
专栏目录
栈与队列经典例题详解
06-06
体育课经常排在上午3、4节，一节课下来大家都筋疲力尽、饥肠辘辘。将近下课，体育老师一吹口哨大家立即集合，不过这次集合大家都站成了一排，然后老师说向右看齐，这时每个人只能看到右侧比自己矮的人头，如果突然出现一个高于或等于自己身高的同学，那么这名同学以及其右侧的同学将会被挡住。那么，问题来了，现给定所有同学的身高（假设体育课大家修炼了一种神秘技能，改变了自己的身高，（身高最大值为2*106），要求每个人能往右侧看到的人数之和（建议使用long long存储）。
算法：Leetcode剑指报价经典算法题型
02-01
其中，快速排序和归并排序因其高效的平均时间复杂度而被广泛使用，而堆排序则常用于实时数据处理，如优先队列。在LeetCode和《剑指Offer》中，你可能会遇到对数组进行排序或找到排序序列中特定元素的问题。 搜索...
LeetCode 题集：栈和队列
星海浮生
11-08 255
LeetCode 232. Implement Queue using Stacks（用栈实现队列） 225. Implement Stack using Queues（用队列实现栈） 150. Evaluate Reverse Polish Notation（逆波兰表达式求值） 71. Simplify Path（简化路径） 155. Min Stack（最小栈） 20. Valid Parentheses（有效的括号）
Leetcode有关栈和队列习题
qq_43185543的博客
09-22 329
20.有效的括号 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 225.用队列实现栈 使用队列实现栈的下列操作： push(x) – 元素 x 入栈 pop() – 移除栈顶元素 top() – 获取栈顶元素 empty(...
LeetCode刷题之队列
辰星的博客
03-16 310
641. 设计循环双端队列 设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 ...
算法与数据结构笔记+leetcode刷题笔记+大厂面试算法题（golang和java实现）.zip
10-03
常见的数据结构有数组、链表、栈、队列、哈希表、堆、树（如二叉树、红黑树、AVL树）、图等。理解每种数据结构的特性和操作，如插入、删除、查找的时间复杂度，对于编写高效代码至关重要。 **LeetCode**： LeetCode...
LeetCode 数据结构与算法（永久分享）
最新发布
03-27
LeetCode经典题型-代码+课件+视频，下载链接 包含了栈，队列，堆；动态规划；二分查找与二分查找树；哈希表与字符串；贪心算法；高级数据结构；递归，回溯与分治；二叉树与图；链表
LeetCode刷题笔记.rar
07-05
在LeetCode中，常见的数据结构包括数组、链表、栈、队列、哈希表、树（二叉树、平衡树如AVL和红黑树等）、图、堆等。每个数据结构都有其独特的特性，例如，数组提供随机访问但插入和删除操作效率低，而链表则相反；...
考研数据结构算法题总结36页（893+408）
07-13
本资料中涉及的数据结构主要包括数组、链表、栈、队列、二叉树等。 1. **数组**：数组是一种基本的数据结构，它允许以固定大小的连续内存空间存储相同类型的数据。在提供的内容中，数组被用于合并排序的数组问题，...
栈和队列经典习题
weixin_43636782的博客
10-13 376
括号匹配问题 问题描述：给定一个包括 ’ ( ‘,’ ) ‘,’ [ ‘,’ ] ‘,’ { ‘,’ } '的字符串，判断字符串是否有效； 字符串需要满足： (1)左括号必须用相同类型的右括号匹配； (2)左括号要以正确的方式闭合； 注意：空字符串被认为是有效字符串； 解题思路： (1)遍历当前字符串，依次取出每个字符；如果当前字符是左括号，就把当前字符入栈； (2)如果当前字符是右括号，那么就取出栈顶元素，看看栈顶元素和当前元素是否匹配. a)匹配：则将栈顶元素出栈，继续取下一个字符； b)不匹配：直接.
LeetCode刷题队列&栈经典例题
yoyoyoyoy6的博客
11-20 424
菜鸡的LeetCode刷题笔记思路
关于栈与队列的一些经典例题
m0_74910523的博客
07-21 144
这几天刷了不少栈与队列的题目，之前这一块没怎么学好，结合近几天在力扣上的题目还是有不少收获的，争取在这个暑假把数据结构与算法这一块学好。接下来分享一些刷到的有意思和比较经典的题目。目录前言1 LeetCode 20.有效的括号2.LeetCode 239.滑动窗口最大值。
LeetCode刷题------栈和队列
weixin_43526403的博客
01-27 254
跟着代码随想录学栈和队列
栈和队列经典题
qq_40192867的博客
05-15 2126
实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1)这道题出栈和入栈都比较好求，关键在于这个返回最小值的时间复杂度，一般来说，要遍历一遍，但是这样时间复杂度就是O（n）,和题意不符，这道题的做法是创建一个结构体，这个结构体中保存着入栈元素的大小，也包含着这个栈中最小的元素，然后再创建一个结构体，这个结构体是栈，入栈的时候直接压入结构体，情况如下所示：te...
栈和队列---leetcode题目+基础知识
m0_58196614的博客
04-01 815
栈和队列的基础详解以及leetcode题目
LeetCode栈和队列经典例题
m0_70811813的博客
01-09 807
这里有四道关于栈和队列的经典题型
【数据结构与算法-栈、队列、堆经典例题汇总】
是小武呀
03-03 1500
【数据结构与算法-栈、队列、堆经典例题汇总】典例1、使用队列实现栈（easy）典例2、使用栈实现队列（easy）典例3、包含min函数的栈（easy）典例4、合法的出栈顺序（medium）典例5、简单的计算器（hard）典例6、数组中第K大的数（medium）典例7、寻找中位数（hard） 典例1、使用队列实现栈（easy） 题目描述： 预备知识 栈：先进后出 基本操作： 队列：先进先出 思路：在元素入栈时候，利用临时队列调换元素的顺序 。 使得 存入队列的元素顺序与栈的顺序
（LeetCode）栈
BrownWong的专栏
06-21 192
1. 最小栈 155. min-stack class MinStack(object): def __init__(self): """ initialize your data structure here. 分析 单纯地用数组实现一个栈很容易，但要实现常数时间检索到最小值就麻烦了； """ self.data = [] self.mins = [] s
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Iceevov

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

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

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

打赏作者

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

抵扣说明：

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

余额充值