栈和队列的几道OJ题（数据结构、C语言、LeetCode）

已于 2022-07-04 22:46:17 修改
阅读量272 收藏
点赞数 2
分类专栏： 数据结构与算法 文章标签： leetcode 数据结构 c语言
于 2022-07-04 22:09:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62080641/article/details/125598396
版权

前言：

  • 本篇博客整理了几道关于栈和队列的OJ题，着重介绍栈和队列之间的互相实现，以及循环队列
  • 代码实现：C语言
  • 题目来源：LeetCode
  • 题目链接：
  1. 有效的括号
  2. 用队列实现栈
  3. 用栈实现队列
  4. 设计循环队列

文章目录

1. 有效的括号

在这里插入图片描述

  • 解决思路：利用栈的特性，先进后出，遍历字符串，把左边的符号（‘(’、‘[’、‘{’）依次存到栈中，然后再逐个出栈和字符串后面的右边的符号比对，符合题意的则继续往下操作。
  • AC代码如下：

typedef char STDateType;//细节
typedef struct Stack
{
	STDateType* a;
	int top;
	int capacity;
}ST;

void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDateType x);
void StackPop(ST* ps);
STDateType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void StackPush(ST* ps, STDateType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDateType* tmp = (STDateType*)realloc(ps->a, sizeof(STDateType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDateType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

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

bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

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

//

bool isValid(char * s){
    ST st;
    StackInit(&st);
    while(*s)
    {
        if(*s == '(' 
        || *s == '[' 
        || *s == '{')
        {
            StackPush(&st, *s);
            ++s;
        }
        else
        {
            if(StackEmpty(&st))
            {
                StackDestroy(&st);
                return false;
            }

            STDateType top = StackTop(&st);
            StackPop(&st);
            if((top == '{' && *s == '}') 
            || (top == '(' && *s == ')') 
            || (top == '[' && *s == ']'))
            {
                ++s;
            }
            else
            {
                StackDestroy(&st);
                return false;
            }

        }
    }

    bool ret = StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}
  • 注意：在返回bool值之前，要将创建的栈销毁，防止内存泄漏。还有诸多控制细节，都在代码中。
2. 用队列实现栈

在这里插入图片描述

  • 解决思路：用C语言解决的话，就得先把队列写出来，才能进行模拟，这里，我们直接调用之前写好的队列即可

在这里插入图片描述

  • AC代码如下：
//链式结构：表示队列
typedef int QDateType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDateType date;
}QNode;

//队列的结构
typedef struct Queue
{
	//int size;
	QNode* head;
	QNode* tail;
}Queue;

//初始化队列
void QueueInit(Queue* pq);

//销毁队列
void QueueDestroy(Queue* pq);

//队尾入队列
void QueuePush(Queue* pq, QDateType x);

//队头出队列
void QueuePop(Queue* pq);

//获取队列头部元素
QDateType QueueFront(Queue* pq);

//获取队列队尾元素
QDateType QueueBack(Queue* pq);

//检测队列是否为空
bool QueueEmpty(Queue* pq);

//获取队列的长度(队列中存放数据的个数)
int QueueSize(Queue* pq);


void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	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, QDateType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail");
		exit(-1);
	}

	newnode->date = 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;
	}
}

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

	return pq->head->date;
}

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

	return pq->tail->date;
}

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

	return pq->head == NULL;
}

int QueueSize(Queue* pq)
{
	assert(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);

    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) {
    Queue* emptyQ = &obj->q1;
    Queue* nonEmptyQ = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ = &obj->q2;
        nonEmptyQ = &obj->q1;
    }

    while(QueueSize(nonEmptyQ) > 1)
    {
        QueuePush(emptyQ,QueueFront(nonEmptyQ));
        QueuePop(nonEmptyQ);
    }

    int top = QueueFront(nonEmptyQ);
    QueuePop(nonEmptyQ);

    return top;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/
  • 注意：本题利用队列模拟了栈，深度复习了栈和队列的相关知识
3. 用栈实现队列

在这里插入图片描述

  • 解决思路：有了第二题的基础，这题也是利用两个栈来回倒数据，可实现队列先进先出的特性，有点类似，但又有一些细节。C语言解决，这里也是要先把栈给写出来，才能进行模拟队列，这里我们也是直接调用之前写好的栈。

在这里插入图片描述

  • AC代码如下：
//动态的栈 支持动态增长
typedef int STDateType;
typedef struct Stack
{
	STDateType* a;
	int top;//栈顶
	int capacity;//容量
}ST;


//初始化栈
void StackInit(ST* ps);

//销毁栈
void StackDestroy(ST* ps);

//入栈
void StackPush(ST* ps, STDateType x);

//出栈
void StackPop(ST* ps);

//获取栈顶元素
STDateType StackTop(ST* ps);

//检测栈是否为空
bool StackEmpty(ST* ps);

//获取栈的长度(栈中存放数据的个数)
int StackSize(ST* ps);


void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void StackPush(ST* ps, STDateType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDateType* tmp = (STDateType*)realloc(ps->a, sizeof(STDateType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDateType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

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

bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

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


//***************


typedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->pushst);
    StackInit(&obj->popst);

    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushst,x);
}

int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->popst))
    {
        // 如果pop栈为空，则把push栈的数据倒过来
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }

    int front = StackTop(&obj->popst);
    StackPop(&obj->popst);
    return front;
}

int myQueuePeek(MyQueue* obj) {
     if(StackEmpty(&obj->popst))
    {
        // 如果pop栈为空，则把push栈的数据倒过来
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }

    return StackTop(&obj->popst);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->popst) && StackEmpty(&obj->pushst);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->pushst);
    StackDestroy(&obj->popst);

    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);
*/
4. 设计循环队列（***）

在这里插入图片描述

  • 解决思路：
    下面先介绍循环队列

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  • AC代码如下：
typedef struct {
    int* a;
    int k;
    int head;
    int tail;
} 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+1));
    obj->head = obj->tail = 0;
    obj->k = k;

    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
        return false;

    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;
    
    obj->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;

    int prev = obj->tail-1;
    if(obj->tail == 0)
        prev = obj->k;

    return obj->a[prev];
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    int next = obj->tail + 1;
    if(next == obj->k+1)
        next = 0;
    
    return next ==  obj->head;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(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);
*/

学习记录：

  • 本篇博客整理于2022.7.4
  • 请多多指教🌹🌹🌹
如何写出最优雅的代码
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
栈队列OJ题分享及讲解
m0_69888254的博客
08-07 580
从今天开始后面的OJ题，我一致用C++来带大家实现，这需要大家先去了解C++STL里面的容器，以及相关的接口。 ## 1、有效的括号 ![在这里插入图片描述](https://img-blog.csdnimg.cn/24f0768e6bc348d7a19e9bb92750f371.png#pic_center) 这题是比较典型的用栈实现的题目，给了我们一个字符串s，让我们去判断里面的括号是否一一匹配。 **解题思路：** ```cpp class Solution { public: bool i
C语言回文数OJ题和答案
10-22
打印所有小于65536且是完全平方数的回文数。
数据结构初阶之队列（C语言实现）
yzy521wjm的博客
05-15 336
数据结构初阶之队列
栈和队列经典OJ题
MEANSWER的博客
10-05 456
栈和队列经典OJ题1. LeetCode第225题---用队列实现栈2. LeetCode第232题---用栈实现队列3. LeetCode第20题---有效的括号4. LeetCode第150题---逆波兰表达式5. LeetCode第155题---最小栈6. 牛客网剑指offer21题---栈的压入、弹出序列 1. LeetCode第225题—用队列实现栈 链接: https://leetcode-cn.com/problems/implement-stack-using-queues/ 题解：用队列
栈和队列OJ题：LeetCode--232.用栈实现队列
Yikefore的博客
05-20 1257
LeetCode--232.用栈实现队列：详细题解以及图解和完整代码。
栈和队列OJ题：LeetCode--225.用队列实现栈
Yikefore的博客
05-19 858
LeetCode--225.用队列实现栈：详细题解以及图解和完整代码。
栈和队列OJ题：LeetCode--20.有效的括号
Yikefore的博客
05-18 613
栈和队列OJ题：LeetCode--20.有效的括号：详细题解以及图解和完整代码
【LeetCode之栈和队列】：关于栈和队列经典的OJ题（用C语言实现，附图详解）
平凡的指针的博客
11-04 594
LeetCode题目1、括号匹配问题2、用队列实现栈3、用栈实现队列4、设计循环队列 1、括号匹配问题 LeetCode链接： 【20. 有效的括号】 这道题就是经典的利用栈解决问题的例子；思路如下： 遍历一遍字符串，如果遇倒左括号就入栈，如果遇倒右括号取栈顶的元素进行匹配并出栈顶的元素，如果相匹配就继续，不匹配就返回false。 但是要注意这样只能检验出左右括号相等的情况下才可以，如果左右括号不相等呢？ 如果左括号多于右括号，并且遍历结束后它们都是匹配的，这种情况并不是完全匹配的，因为栈里还有元素剩余
【数据结构】栈与队列经典oj题
睿的博客
04-08 879
学会了栈与队列相关知识，快来刷题提升自己吧！
【LeetCode】栈和队列OJ题---C语言版
weixin_75128035的博客
11-30 706
此题可以用两个栈实现，一个栈进行入队操作，另一个栈进行出队操作出队操作： 当出队的栈不为空是，直接进行出栈操作，如果为空，需要把入队的栈元素全部导入到出队的栈，然后再进行出栈操作。出栈操作相当于非空队列的队尾元素出队，此时需要把非空队列除最后一个元素之外的其余元素入队到空队列，然后出队最后一个队尾元素。我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！此题可以用两个队列去实现一个栈，每次始终保持一个队列为空，入栈操作相当于给非空队列进行入队操作。好了，今天的分享就到这里了。
swust西南科技大学OJ数据结构80题答案
10-14
整理了西南科技大学OJ上的全部80道数据结构考试题目代码
OJ，数据结构，算法等的一个杂集.zip
12-28
OJ，数据结构，算法等的一个杂集 OJ，数据结构，算法等的一个杂集 OJ，数据结构，算法等的一个杂集 OJ，数据结构，算法等的一个杂集 OJ，数据结构，算法等的一个杂集 OJ，数据结构，算法等的一个杂集 OJ，数据结构，...
西南科技大学SWUST OJ 数据结构 图相关题题解 图.zip
01-01
SWUST OJ ： 1055、1056、1057、1058、1059、1060、1061、1062、1063、1064、1065、1066、1067、1068、1069、1070、1071、1072、1075、1086题答案
数据结构（清华大学版）——栈和队列
04-19
数据结构（清华大学版）——栈和队列
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 402
【代码】力扣LCP 08.剧情触发时间。
【代码随想录算法训练Day35】LeetCode 1005. K 次取反后最大化的数组和、LeetCode 134.加油站、LeetCode 135.分发糖果
qq_46121420的博客
06-11 220
贪心第三天
【回溯】Leetcode 77. 组合【中等】
FLGB
06-11 249
你可以按 任何顺序 返回答案。
链表经典题目：环形链表问题（LeetCode141.环形链表、LeetCode142.环形链表Ⅱ）
最新发布
iiiiiankor的博客
06-15 719
🌟🌟🌟环形链表问题在面试中是经常爱考的，你有没有发现环形链表的题目代码都没有很难，一般是思路难以想到，所以人家考你的是思路，并不真的会纠你代码写的怎么样！快指针必须一次走2步吗？可以一次走3步，走4步可以吗？你会怎么回答？怎么证明快指针一次走2步一定可以追上？这里我们简单证明一下：➡️快指针一次走2步那么一定可以追得上首先需要知道，fast什么时候开始追击slow因为fast首先进入环，在slow进环之前，二者的运动路径并不一样！只有当slow也开始进环，才开始所谓的追及问题。
西南科技oj数据结构
09-09
西南科技oj数据结构是指西南科技大学开发的一套用于编程竞赛的在线评测系统中，用于测试和评判学生对数据结构知识的掌握情况的题目。数据结构是计算机科学中的重要内容，它主要研究如何组织和存储数据以及如何高效地处理各种数据操作。 西南科技oj数据结构题目的特点是，它们涵盖了数据结构的各个方面，如线性表、栈、队列、链表、树、图等。每个题目都要求学生根据题目描述和要求，设计和实现相应的数据结构，然后使用合适的算法对数据进行操作和处理。 在解决这些题目时，学生需要具备一定的数据结构基础知识，如数组、链表、栈和队列的基本操作，以及树和图的遍历算法、最短路径算法等。此外，对于每个题目，学生还需要分析问题的特点和要求，选择合适的数据结构和算法，使得程序能够高效地运行。 通过西南科技oj数据结构题目的练习，学生能够加深对数据结构的理解和运用能力，同时也能够提高编程和算法设计的水平。这对于学生在进行编程竞赛和实际工程开发中都非常有帮助。 总之，西南科技oj数据结构题目的设计旨在帮助学生掌握和应用数据结构知识，提高编程和算法设计的能力。通过解决这些题目，学生能够在实践中提升自己的能力，并为日后的学习和工作打下坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

如何写出最优雅的代码

感谢支持，我将继续努力！

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

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

打赏作者

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

抵扣说明：

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

余额充值