栈和队列oj题自测

最新推荐文章于 2024-10-30 16:47:45 发布
最新推荐文章于 2024-10-30 16:47:45 发布
阅读量356 收藏 18
点赞数 27
分类专栏： 数据结构 文章标签： 算法 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67401157/article/details/129677787
版权

1.LeetCode225 用队列实现栈

在这里插入图片描述
解题思路：
此题可以用两个队列去实现一个栈，每次始终保持一个队列为空。

  1. 入栈操作相当于给非空队列进行入队操作
  2. 出栈操作相当于非空队列的队尾元素出队，此时需要把非空队列除最后一个元素之外的其余元素入队到空队列，然后出队最后一个队尾元素

入栈图示：
在这里插入图片描述
出栈图示：
在这里插入图片描述
代码实现：

typedef int QDatatype;

typedef struct QueueNode
{
	struct QNode* next;
	QDatatype data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

void QueueInit(Queue* q);
void QueuePush(Queue* q, QDatatype x);
void QueuePop(Queue* q);
QDatatype QueueFront(Queue* q);
QDatatype QueueBack(Queue* q);
int Queuesize(Queue* q);
int QueueEmpty(Queue* q);
void QueueDestroy(Queue* q);

void QueueInit(Queue* q)
{
	assert(q);
	q->head = q->tail = NULL;
	q->size = 0;
}
void QueuePush(Queue* q, QDatatype x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

	//队列为空
	if (q->head == NULL)
	{
		assert(q->tail == NULL);
		q->head = q->tail = newnode;
	}
	//队列不空
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}
void QueuePop(Queue* q)
{
	assert(q);
	assert(q->head != NULL);
	//队中只有一个元素
	if (q->head->next == NULL)
	{
		free(q->head);
		q->head = q->tail = NULL;
	}
	else
	{
		QNode* next = q->head->next;
		free(q->head);
		q->head = next;
	}
	q->size--;
}
QDatatype QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}
QDatatype QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->tail->data;
}
int Queuesize(Queue* q)
{

	assert(q);
	return q->size;
}
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->size == 0;
}
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->head = q->tail = NULL;
	q->size = 0;
}

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


MyStack* myStackCreate() {
    MyStack* tst=(MyStack*)malloc(sizeof(MyStack));
    if(tst==NULL)
    {
        perror("malloc fail");
        return NULL;
    }
    QueueInit(&tst->q1);
    QueueInit(&tst->q2);
    return tst;

}
//往有数据的队列里插入
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* noneemptyQ=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ=&obj->q2;
        noneemptyQ=&obj->q1;
    }
    while(Queuesize(noneemptyQ)>1)
    {
        QueuePush(emptyQ,QueueFront(noneemptyQ));
        QueuePop(noneemptyQ);
    }
    int top=QueueFront(noneemptyQ);
    QueuePop(noneemptyQ);

    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);
}

2.LeetCode232 用栈实现队列

在这里插入图片描述
解题思路：
此题可以用两个栈实现，一个栈进行入队操作，另一个栈进行出队操作。

  • 出队操作： 当出队的栈不为空时，直接进行出栈操作，如果为空，需要把入队的栈元素全部导入到出队的栈，然后再进行出栈操作。

入队图示：
在这里插入图片描述
出队图示：
在这里插入图片描述
代码实现：

typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;

void STinit(ST* ps);
void STDestory(ST* ps);
void STPush(ST* ps,STDataType x);
void STPop(ST* ps);
int STSIze(ST* ps);
bool STEmpty(ST* ps);
STDataType STTop(ST* ps);

void STinit(ST* ps)
{
    assert(ps);
    ps->a=(STDataType*)malloc(sizeof(STDataType)*4);
    if(ps->a==NULL)
    {
        perror("mallloc fali");
        return ;
    }
    ps->top=0;
    ps->capacity=4;
}
void STDestory(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a=NULL;
    ps->top=0;
    ps->capacity=0;
}
void STPush(ST* ps,STDataType x)
{
    assert(ps);
    if(ps->top==ps->capacity)
    {
        STDataType* tem=(STDataType*)realloc(ps->a,sizeof(STDataType)*ps->capacity*2);
        if(tem==NULL)
        {
            perror("realloc fail");
            return ;
        }
        ps->a=tem;
        ps->capacity*=2;
    }
    ps->a[ps->top]=x;
    ps->top++;
}

bool STEmpty(ST* ps)
{
    assert(ps);
    return ps->top==0;
}
void STPop(ST* ps)
{
    assert(ps);
    assert(!STEmpty(ps));
    ps->top--;
}
int STSIze(ST* ps)
{
    assert(ps);
    return ps->top;
    
}

STDataType STTop(ST* ps)
{
    assert(ps);
    assert(!STEmpty(ps));

    return ps->a[ps->top-1];
}
typedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    if(obj==NULL)
    {
        perror("malloc fail");
        return NULL;
    }
    STinit(&obj->pushst);
    STinit(&obj->popst);

    return obj;
}

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

int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }
    return STTop(&obj->popst);
}

int myQueuePop(MyQueue* obj) {
    int front=myQueuePeek(obj);
    STPop(&obj->popst);
    return front;
}


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

void myQueueFree(MyQueue* obj) {
    STDestory(&obj->pushst);
    STDestory(&obj->popst);
    free(obj);
}

3.LeetCode20 有效的括号

在这里插入图片描述
解题思路：
当遇到一个左括号时，先将这个左括号放入栈顶，当遇到一个右括号时，取出栈顶的左括号并判断它们是否是相同类型的括号。如果不是相同的类型，或者栈中并没有左括号，那么该字符串无效，如果是相同类型，则继续匹配，直到该字符串末尾。
代码实现：

typedef char  STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

//先声明
void STInit(ST* ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
int STSize(ST* ps);
bool STEmpty(ST* ps);
STDataType STTop(ST* ps);
//再定义
void STInit(ST* ps)
{
	assert(ps);

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}

	ps->capacity = 4;
	ps->top = 0;   // top是栈顶元素的下一个位置

	//ps->top = -1;   // top是栈顶元素位置
}

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

	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void STPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a,
			sizeof(STDataType) * ps->capacity*2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		ps->a = tmp;
		ps->capacity *= 2;
	}

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

void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

	ps->top--;
}

int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

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

	return ps->top == 0;
}

STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

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

bool isValid(char * s){
    ST st;
    STInit(&st);
    while(*s)
    {
        if(*s=='('||*s=='['||*s=='{')
        {
            STPush(&st,*s);
        }
        else 
        {
            if(STEmpty(&st))
            {
                STDestroy(&st);
                return false;
            }
            char top=STTop(&st);
            STPop(&st);
            
            if(*s==')'&&top!='('||
               *s==']'&&top!='['||
               *s=='}'&&top!='{')
               {
                   STDestroy(&st);
                   return false;
               }
        }
        ++s;
    }
    bool res=STEmpty(&st);
    STDestroy(&st);
    return res;

}

4.LeetCode622 设计循环队列

在这里插入图片描述

解题思路：

通过一个定长数组实现循环队列

  1. 入队：首先要判断队列是否已满，再进行入队的操作，入队操作需要考虑索引循环的问题，当索引越界，需要让它变成最小值
  2. 出队：首先要判断队列是否为空，再进行出队操作，出队也需要考虑索引循环的问题
  • 判空： 队头 == 队尾
  • 判满： 队尾 + 1 == 队头
    在这里插入图片描述
    代码实现：
typedef struct {
    int *a;
    int front;
    int rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));
    obj->front=obj->rear=0;
    obj->k=k;
    return obj;
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->front==(obj->rear+1)%(obj->k+1);
}

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

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

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

本篇到此结束，码文不易，还请多多支持哦！

殿下p
关注
专栏目录
【数据结构】栈与队列经典oj题
睿的博客
04-08 1062
学会了栈与队列相关知识，快来刷题提升自己吧！
【数据结构】栈和队列OJ练习(栈和队列相互实现+循环队列实现)
Edward_Asia的博客
11-03 2793
前言 前面在学习了栈和队列的实现之后，相信大家对栈和队列的结构和使用方式都有了一些理解。 下面我们就来进行一些练习，这这章的练习相对于原来在难度上有了一些提升。 原来的题只需要实现一个接口，而今天的练习题需要实现多个接口。 1.用队列实现栈 225. 用队列实现栈 - 力扣（LeetCode） (leetcode-cn.com) 栈：后进先出；队列：先进先出 方法： 创建两个队列，用来来回导数据。 入栈：将数据放入不为空的队列。 出栈：将不为空的队列中的数据以出队入栈的方式.
栈和队列的实现以及相关OJ题目
qq_57770005的博客
05-24 420
栈和队列的实现以及相关OJ题目一、栈1.栈的概念及结构2.栈的动态实现3.有关于栈的OJ题目3.1括号匹配问题二、队列1.队列的概念以及结构2.队列的实现3.队列的OJ题目3.1用队列实现栈3.2用栈实现队列3.3循环队列总结 一、栈 1.栈的概念及结构 栈：是一种特殊的·线性表，其只允许在固定的一端进行插入和删除元素操作 进行数据插入和删除操作的一端成为栈顶，另一端成为栈底。 栈遵循的原则：是先进后出。 2.栈的动态实现 栈的实现一般可以使用数组或者链表来实现，相对而言数组的结构实现会更优， 因为在
栈和队列OJ题讲解
bushibrnxiaohaij的博客
08-07 985
👀👀👀👀👀👀🌹欢迎大家三连关注，一起学习，一起进步！！💓。
栈和队列经典oj面试题
qq_68844357的博客
08-24 340
二、用队列实现栈 三. 用栈实现队列 四. 设计循环队列 总结
4.2较难的栈和队列OJ
E_han的博客
08-24 641
本篇博客来手撕三道稍有难度的栈和队列相关OJ，题目均已插入超链接，点击即可跳转~
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 2296
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
OJ题目【栈和队列】
2301_80216111的博客
06-04 1059
栈和队列的OJ题目
栈和队列OJ练习——栈实现队列，队列实现栈
qq_67611811的博客
08-26 882
栈与队列的数据存储方式完全不同，栈的数据遵循先进后出模式FILO，而队列为先进先出模式FIFO，要想使用栈的结构实现队列的数据增删模式，需要使用栈的性质并对其稍加巧用，就可以达到同队列的数据存储访问相同的效果。注意，本章中用栈实现队列所用到的栈函数，以及队列实现栈使用到的队列接口函数都在上一章模拟实现提及到，详情请参照上一章，链接在此数据结构——栈和队列_VelvetShiki_Not_VS的博客-CSDN博客。定义两个栈，一个用于临时存放压栈的数据，命名其为Push栈，再定义一个专用于出数据的栈Pop，当
【学懂数据结构】栈和队列（入门学习）
桦楸静的博客
08-08 380
栈和队列是数据结构的基础知识，本文就来分享一波笔者对于栈和队列的学习心得，由于水平有限，难免存在纰漏，还请见谅。
mooc-清华数据结构与算法(邓俊辉) OJ习题.zip
01-05
3. **栈**：后进先出（LIFO）的数据结构，常用于表达式求值和递归计算。 4. **队列**：先进先出（FIFO）的数据结构，常见于任务调度和多线程编程。 5. **树**：分层的数据结构，如二叉树、平衡树（AVL、红黑树）等，...
蓝桥杯历年试题（附完整测试数据和题目描述，可导入Oj)
03-15
这些题目是提高编程基本功的重要途径，通过解决这些题目，学习者可以熟悉常见的算法思想和数据结构，如快速排序、二分查找、深度优先搜索（DFS）和广度优先搜索（BFS），以及如何使用栈、队列、树和图等数据结构解决...
swust oj.rar_oj.swust_swust oj答案_swust oj 第580题_swust oj 答案_swu
09-24
`oj.swust.swust_oj答案`和`swust_oj_第580题`标签表明，这个压缩包文件包含了有关SWUST OJ平台上的第580题目的解答。`swust_oj_答案`和`swust_prow_oj`标签可能是对平台上的其他题目或相关资源的引用，可能包括解决...
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2289
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
C++ | Leetcode C++题解之第514题自由之路
Ddddddd_158的博客
10-27 343
C++ | Leetcode C++题解之第514题自由之路
力扣 中等 198.打家劫舍
qq_51352130的博客
10-25 436
法一：动态规划 和716最少花费爬楼梯思路一样链接确定dp数组（dp table）以及下标的含义：dp[i]的定义为到第i号房屋能偷窃到的最高金额为dp[i]确定递推公式：可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。所以 dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1])dp数组如何初始化：dp[0] = nums[0];确定遍历顺序举例推导dp数组// nums.length是大于等于1的。
数对的最大曼哈顿距离[ABC178E] Dist Max
最新发布
2301_80882026的博客
10-30 224
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
【支持在线评测】二叉树计算
春秋招笔试突围
10-28 28
给定一个二叉树，请生成一个新的二叉树，使得新树中的每个节点的值等于原始树中该节点的左子树和右子树所有节点值的和。左子树表示该节点左侧叶子节点为根节点的一颗新树；右子树表示该节点右侧叶子节点为根节点的一颗新树。首先，需要根据给定的中序遍历和前序遍历序列重建原始二叉树。这是因为只有重建出原始树的结构，才能正确计算每个节点的子树和。在重建树的过程中，同时计算每个节点的子树和。输出一行整数，表示生成的新二叉树（求和树）的中序遍历序列，以空格分隔。最后，对重建并计算好子树和的树进行中序遍历，输出结果。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3488
BSP驱动开发工程师-OS、4 道编程题
清华邓俊辉数据结构与算法OJ习题解析
数据结构主要分为线性结构和非线性结构两大类，线性结构主要包括数组、链表、栈、队列等，而非线性结构则包括树、图等。每种数据结构都有其特定的用途和优势，在实际应用中需要根据具体问题选择合适的数据结构。 在...
评论 56
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

殿下p

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

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

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

打赏作者

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

抵扣说明：

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

余额充值