Leetcode:栈和队列的互相实现

最新推荐文章于 2024-10-30 23:49:15 发布
最新推荐文章于 2024-10-30 23:49:15 发布
阅读量1.9k 收藏 73
点赞数 105
文章标签： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81271741/article/details/142629910
版权

目录

一、用两个队列实现栈

题目：

分析：

代码实现：

 二、用两个栈实现队列

题目：

 分析：

代码：

总结：核心就在于先进先出和后进先出之间的一个灵活变换，两个栈能够先进先出，而两个队列能够后进先出 

一、用两个队列实现栈

题目：

. - 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=O83Ahttps://leetcode.cn/problems/implement-stack-using-queues/description/

 

分析：

首先，我们明确队列有几个接口，初始化、入队、出队、取队头、取队尾、判空、返回有效元素个数、销毁。

题目要求只使用队列标准操作实现栈的四种操作，push、pop、top、empty,实际要求我们主要要能够实现栈存储元素后进先出的特点即可。

那如何利用两个队列实现栈的后进先出呢？

 

代码实现：

（注释在代码中哦，一些错误的代码我给注释掉的不用管）

//两个队列，一个装元素，另一个用来倒

typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* next;
    QDataType data;
}QNode;

//定义一个包含队头和队尾的结构体
typedef struct Queue
{
	QNode* front;
	QNode* rear;
    int size;//标记队列中元素个数
}Queue;

void QueueInit(Queue* q)
{
	assert(q);
	/*QNode* tem = (QNode*)malloc(sizeof(QNode));
	if (tem == NULL)
	{
		perror("malloc");
		return;
	}*/
	q->front = q->rear = NULL;
	//q->front->next = NULL;
	//q->front->data = 0;
	q->size = 0;
}

//通过尾插在队尾入队列
void QueuePush(Queue* q,QDataType x)
{
	assert(q);
	QNode* tem = (QNode*)malloc(sizeof(QNode));
	if (tem == NULL)
	{
		assert("malloc");
		return;
	}
    
	if (q->front == NULL)//第一个节点
	{
		q->front = q->rear = tem;
		q->front->data = x;
        tem->next=NULL;//别忘了tem的next置空
	}
	else//第二及以后节点
	{
		q->rear->next = tem;
		q->rear = tem;
		q->rear->next = NULL;
		q->rear->data = x;
	}
	q->size++;

    // tem->next = NULL;
    // tem->data = x;
    // if (q->rear == NULL) {
    //     q->front = q->rear = tem;
    // } else {
    //     q->rear->next = tem;
    //     q->rear = tem; // 更新tail的指向
    // }
 
    // q->size++; // push一下节点个数++

}

//通过头删实现在队头出队列
void QueuePop(Queue* q)
{
	assert(q);
	assert(q->front);//头指针不为空才存在删
	QNode* tem = q->front;
	q->front = q->front->next;
	if (q->front == NULL)
		q->rear = NULL;//避免尾指针变成野指针
	free(tem);
	q->size--;
}

//获取队列头部元素
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->front);
	return q->front->data;
}

//获取队列尾部元素
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->rear);
	return q->rear->data;
}

//获取队列中有效元素个数
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* q)
{
	if (q->size == 0)
		return 1;
	else
		return 0;
}

//销毁队列
void QueueDestroy(Queue* q)
{
    assert(q);
    while(q->front)
    {
        QNode* tem=q->front;
        q->front=q->front->next;
        free(tem);
    }
    q->rear=NULL;
    q->size=0;
    //assert(pq);

	// QNode* cur = pq->front;
	// while (cur)
	// {
	// 	QNode* next = cur->next;
	// 	free(cur);

	// 	cur = next;
	// }

	// pq->front = pq->rear = NULL;
	// pq->size = 0;
}

//上面都是队列的接口，因为此处是用C语言实现，所以得写一下
//接下来才是栈的实现

typedef struct {
    Queue q1;//定义两个队列
    Queue q2;
} MyStack;

// typedef struct Stack
// {
//     int* arr;
//     int top;
//     int capacity;
// }

//初始化
//在本题由于栈的4种操作的实现完全依赖于队列，对栈的初始化就是对两个队列的初始化
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);
}

//出栈
//关键在于找到空队列，将不为空队列的前size-1个元素导到空队列，剩下的那1个元素则头删，从而实现栈的后进先出
int myStackPop(MyStack* obj) {
    //假定q1为空队列
    Queue* Empty=&obj->q1;
    Queue* No_Empty=&obj->q2;
    if(!QueueEmpty(Empty))//假定错误则调换
    {
        Empty=&obj->q2;
        No_Empty=&obj->q1;
    }
    //找到了空队列和不为空队列，接下来实现不为空队列的前size-1个元素导到空队列
    while(QueueSize(No_Empty)>1)
    {
        int tem=QueueFront(No_Empty);
        QueuePush(Empty,tem);//先将非空队列的元素压到空队列
        QueuePop(No_Empty);//再头头删掉它
    }
    //不为空队列的最后一个元素删除和返回
    int tem=QueueFront(No_Empty);
    QueuePop(No_Empty);
    return tem;
}

//取栈顶元素
int myStackTop(MyStack* obj) {
    // //假定q1为空队列
    // Queue* Empty=&obj->q1;
    // Queue* No_Empty=&obj->q2;
    // if(!QueueEmpty(Empty))//假定错误则调换
    // {
    //     Empty=&obj->q2;
    //     No_Empty=&obj->q1;
    // }
    // //找到了空队列和不为空队列，接下来实现不为空队列的前size-1个元素导到空队列
    // while(QueueSize(No_Empty)>1)
    // {
    //     int tem=QueueFront(No_Empty);
    //     QueuePush(Empty,tem);
    //     QueuePop(No_Empty);
    // }
    // //不为空队列的最后一个元素返回
    // int tem=QueueBack(No_Empty);
    // //QueuePop(No_Empty);
    // return tem;
    
    if(!QueueEmpty(&obj->q1))
    return QueueBack(&obj->q1);
    else
    return QueueBack(&obj->q2);
}

//判空
bool myStackEmpty(MyStack* obj) {
    if(QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2))
    return true;
    else
    return false;
    //return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

//销毁栈
//即销毁掉两个队列
void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

 

 二、用两个栈实现队列

题目：

. - 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=O83Ahttps://leetcode.cn/problems/implement-queue-using-stacks/description/

 

 分析：

与上面的思路类似，不同之处在于栈的的特点是后进先出，要实现队列的先进先出的话，除了要将后进的size-1个元素导到另一个栈，将最先进的元素通过出栈pop删除，为了以后能够继续重复此操作，还要再将导过去的元素再导回来。

注意在本题实现队列的出队pop时，最关键的就在于还要导回去！！！！

代码：

typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;
	int top;//栈中元素个数
	int capacity;//栈容量
}Stack;

//扩容函数
void Exp(Stack* p)
{
	if (p->capacity == p->top)
	{
		int new_capacity = p->capacity == 0 ? 4 : p->capacity * 2;//三目运算
		STDataType* tem = (STDataType*)realloc(p->arr, new_capacity * sizeof(STDataType));//注意是p->arr，不是p
		if (tem == NULL)//对返回值判断
		{
			perror("realloc");
			exit(1);
		}
		p->capacity = new_capacity;
		p->arr = tem;
	}
}

//初始化栈
void InitStack(Stack* p)
{
	assert(p);
	p->arr = NULL;
	p->top = 0;
	p->capacity = 0;
}

//入栈
void PushStack(Stack* p, STDataType x)
{
	assert(p);
	Exp(p);
	p->arr[p->top] = x;//元素入栈顶
	p->top++;
}

//出栈
void PopStack(Stack* p)
{
	assert(p);
	assert(p->top > 0);//有元素才能出
	p->top--;
}

//取栈顶元素
STDataType TopStack(Stack* p)
{
	assert(p);
	assert(p->top > 0);
	return p->arr[p->top - 1];//top相当于size，而数组下标是从0开始的
}

//获取栈中有效元素个数
int SizeStack(Stack* p)
{
	assert(p);
	return p->top;
}

//判空
bool EmptyStack(Stack* p)
{
	assert(p);
	//确实栈中元素为0则为true,否则为false
	return !p->top;
}

void DestroyStack(Stack* p)
{
	assert(p);
	if (p->arr)//arr非空指针时才存在释放问题
	{
		free(p->arr);//释放掉动态申请的内存
		p->arr = NULL;//置空
		p->capacity = p->top = 0;
	}
}

//以上都是栈的接口
//接下来才是用栈实现队列

typedef struct {
    Stack s1;//定义两个栈
    Stack s2;
} MyQueue;

//对队列的初始化即对两个栈的初始化
MyQueue* myQueueCreate() {
    MyQueue* tem=(MyQueue*)malloc(sizeof(MyQueue));
    InitStack(&tem->s1);
    InitStack(&tem->s2);
    return tem;//不要忘了返回！！！
}

//同样，始终保持一个栈为空，而另一个不为空,往不为空的栈压
void myQueuePush(MyQueue* obj, int x) {
    if(!EmptyStack(&obj->s1))
    PushStack(&obj->s1,x);
    else
    PushStack(&obj->s2,x);
}

//队列的头删
//
int myQueuePop(MyQueue* obj) {
    assert(obj);
    //assert((!EmptyStack(&obj->s1) || !EmptyStack(&obj->s2));//两个栈都为空就不存在后面问题
    //假设
    Stack* Empty=&obj->s1;
    Stack* No_Empty=&obj->s2;
    if(!EmptyStack(Empty))//假设错误调换
    {
        Empty=&obj->s2;
        No_Empty=&obj->s1;
    }
    //实现头删
    //1.找到先进的元素
    while(SizeStack(No_Empty)>1)
    {
        int tem=TopStack(No_Empty);//取栈顶元素
        PopStack(No_Empty);//删除栈顶元素
        PushStack(Empty,tem);//压入另一个空栈
    }
    //2。删除
    int tem=TopStack(No_Empty);
    PopStack(No_Empty);
    //3.将在另一个栈中的元素导回去，以便下次头删
    while(!EmptyStack(Empty))
    {
    int tem=TopStack(Empty);
    PopStack(Empty);
    PushStack(No_Empty,tem);
    }
    return tem;
}

//返回队列开头元素
int myQueuePeek(MyQueue* obj) {
    assert(obj);
    //assert((!EmptyStack(&obj->s1) || !EmptyStack(&obj->s2));//两个栈都为空就不存在后面问题
    if(!EmptyStack(&obj->s1))
    return (&obj->s1)->arr[0];
    else
    return (&obj->s2)->arr[0];
}

//判空
bool myQueueEmpty(MyQueue* obj) {
    return EmptyStack(&obj->s1) && EmptyStack(&obj->s2);
}

void myQueueFree(MyQueue* obj) {
    assert(obj);//销毁栈即销毁队列
    DestroyStack(&obj->s1);
    DestroyStack(&obj->s2);

}

 

总结：核心就在于先进先出和后进先出之间的一个灵活变换，两个栈能够先进先出，而两个队列能够后进先出 

 （栈和队列还不是很清楚的铁铁可以看我前面博客哦）

好想当只懒羊羊
关注
leetcode:leetcode答案
04-27
密码 leetcode答案
leetcode答案-leetCode:leetCode答案
06-30
LeetCode涵盖的算法主要分为数据结构和算法两大类，包括但不限于数组、链表、栈、队列、哈希表、二叉树、图、排序、搜索、动态规划等。通过解决这些问题，开发者可以提高对这些数据结构和算法的理解和应用能力。 1....
Leetcode: 栈和队列的互相实现
小蜗牛的珍贵百宝箱
10-21 261
本文介绍了如何通过栈和队列的互相实现，展示了两种数据结构之间的关系和转换。无论是在 Leetcode 上的面试问题，还是在实际开发中，掌握这两种数据结构的实现和相互转换都是非常重要的。希望通过本篇文章，读者能够更深入理解栈和队列的特性及其实现方法。如果你有任何问题或者想法，欢迎在评论区讨论！
力扣：栈和队列互相实现java
qq_42325147的博客
10-11 115
力扣：栈和队列互相实现java
leetcode 栈和队列的互相实现
Allen9012的博客
11-20 790
leetcode 栈和队列的互相实现1. 用队列实现栈1.1 题目描述1.1.1 接口函数1.2 大致框架1.2.1 想法和思路1.2.2 具体步骤先实现一个栈`MyStack``myStackCreate``myStackPush``myStackPop``myStackTop``myStackEmpty``myStackFree`1.2.3 测试时发生的错误解决第一个错误解决第二个错误解决第三个错误1.3 整体实现2. 用栈实现队列2.1 题目描述2.1.1 接口函数2.2 大致框架2.2.1 想法和思
leetcode 堆栈（栈+优先队列）——java实现
weixin_44040169的博客
08-19 718
Deque mstack = new LinkedList();栈 PriorityQueue minHeap = new PriorityQueue();小顶堆（优先队列）
Leetcode刷题之栈和队列互相实现
qq_34190232的博客
08-23 163
一、用栈实现队列 1、问题描述 使用栈实现队列的下列操作： push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1...
栈和队列的互相实现
CZHLNN的博客
02-18 318
栈和队列1 栈和队列3 用栈实现队列3.1 思路分析3.2 代码实现4 用队列实现栈4.1 思路分析4.2 代码实现 1 栈和队列 栈： 后进先出的数据结构 队列：先进先出的数据结构 如图所示： 那么以C++为例，自己使用的编程语言里栈和队列是什么样的呢。可以思考以下几个方面： C++中的 stack 是容器吗？ 我们使用的stack是属于哪个版本的 STL ? 我们使用STL中的 stack 是怎么实现的呢？ stack 提供迭代器来遍历 stack 空间吗？ C++标准库是有多个版本的，
LeetCode_栈和队列(Stacks & queues)相关OJ
QinMou
05-13 871
将mystack结构体里面创建两个队列q1、q2。创建两个栈st1、st2一个int*指针、一个head、一个tail、一个k表示队列容量。
c语言栈和队列编程题,leetcode c语言题解（4）——栈和队列互相实现的优化版
weixin_30030437的博客
05-25 180
栈和队列互相实现FIFO和FILO，相当于+-号，互转都是利用“负负得正”的原理。1. 栈实现队列官方解答中第二种思路很6，按需反转，这样摊还分析下来，复杂度变成了O(1)class MyQueue {private:stack s1;stack s2;public:/** Initialize your data structure here. */MyQueue() {}/** Push el...
【leetcode】栈与队列刷题总结
zs16113的博客
07-09 361
需要两个栈（一个，一个）来实现队列操作在push数据的时候，只要数据放进输入栈就好。但在pop的时候，输出栈如果为空，就把输入栈数据全部导入进来，再弹出数据；如果输出栈不为空，则直接弹出数据就可以。
leetcode卡-leetcode:leetcode
07-06
同时，对数据结构的理解也至关重要，如数组、链表、栈、队列、树、哈希表等。通过LeetCode，开发者可以深入理解并熟练运用这些基础概念。 3. **实战训练**：LeetCode的题目设计贴近实际编程场景，有助于用户将理论...
leetcode卡-leetcode:leetcode打卡
07-06
1. **数据结构**：链表、树、堆、栈、队列、哈希表、图等，这些都是LeetCode中常见的题目背景，理解和熟练运用这些数据结构是解决问题的关键。 2. **排序与搜索**：快速排序、归并排序、二分查找、哈希映射等，这些...
leetcode答案-leetcode:leetcode问题解答
06-30
例如，数据结构中的链表、树、队列、栈等基础概念，通过LeetCode的问题可以得到深入的理解和应用。排序算法如快速排序、归并排序、堆排序等，在LeetCode的实战中，我们能够了解到它们的优缺点以及适用场景。搜索算法...
二叉树习题其六【力扣】【算法学习day.13】
2301_79232523的博客
10-25 592
书接上篇文章二叉树习题其四，这篇文章我们将基础拓展###我做这类文档一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？）我的解析也不会做的非常详细，只会提供思路和一些关键点，力扣上的大佬们的题解质量是非常非常高滴！！！
【力扣 + 牛客 | SQL题 | 每日5题】牛客SQL热题216，217，223
2301_80912559的博客
10-30 907
你正在搭建一个用户活跃度的画像，其中一个与活跃度相关的特征是“最长连续登录天数”， 请用SQL实现“2023年1月1日-2023年1月31日用户最长的连续登录天数”一句话：两个记录的日期的差值如果等于两记录的排名差值，说明中间一直是连续的。使用join查询方式找出没有分类的电影id以及其电影名称。这不一眼窗口函数么。
Java | Leetcode Java题解之第514题自由之路
m0_57195758的博客
10-27 293
Java | Leetcode Java题解之第514题自由之路
【力扣专题栏】合并K个升序链表，3种解法讲解如何实现vector容器里面多个链表的合并？
最新发布
2301_78704584的博客
10-30 310
解释：首先vector容器里面放有多个元素，每个元素是一个链表，每个链表含有0个或多个节点。当到达递归结束条件时，就开始往回归并。
力扣-最小覆盖子串
Dennis_nafla的博客
10-29 276
可以定义一个distance这样的int变量，当移动右指针后，如果此时右指针指向的字符在当前窗口中的个数严格小于t中所需要的个数，那么distance++。滑动窗口，初始时左右指针都指向s的第一个字符,对于每个遍历到的窗口，判断当前窗口是否包含了t中所需要的所有字符，不是的话就移动右指针，是的话就移动左指针。在移动左指针前,如果此时左指针指向的字符在当前窗口中的个数等于t中所需要的个数，那么distance--。给定一个字符串s,和目标字符串t，需要找出s中包含t中所有字符且长度最小子串，输出这个子串。
评论 83
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

好想当只懒羊羊

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

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

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

打赏作者

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

抵扣说明：

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

余额充值