用双栈实现队列，巧妙运用栈原理模拟队列特性

最新推荐文章于 2024-04-22 23:20:09 发布
最新推荐文章于 2024-04-22 23:20:09 发布
阅读量172 收藏
点赞数
分类专栏： 算法题 # 栈与队列 文章标签： 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44196733/article/details/132539367
版权

题目

用栈实现队列

思路

创建两个栈，一个输入栈专门用来压入Push传入的数据，一个输出栈专门用来弹出pop和peek访问的栈顶数据。

增加数据入队时，就将数据全部压入输入栈；

弹出数据出队时，若输出栈为空则将输入栈的全部数据依次弹出并压入输出栈，等待弹出。这样输出栈从栈顶到栈底的元素顺序就是从队首到队尾的顺序。

代码实现

创建栈

声明一个栈数据类型，用于向操作系统申请内存和告诉程序员该存放什么数据。

//创建栈结构
typedef int STDataType;
typedef struct Stack
{
	int top; //指向栈顶元素的下一个位置
	int capacity;
	STDataType* a; //动态数组
} ST;

值得注意，top定义为栈顶元素的下一个位置，因为top将从0开始，方便统计栈内数据个数。

实现栈

//实现栈的函数
//栈的初始化
void STInit(ST* pst);

//栈的填入数据
void STPush(ST* pst, STDataType x);

//栈的删除数据
void STPop(ST* pst);

//栈的判空
bool STEmpty(ST* pst);

//栈的栈顶元素访问
STDataType STTop(ST* pst);

//栈的大小计算
int STSize(ST* pst);

//栈的销毁
void STDestroy(ST* pst);


//实现栈的函数
//栈的初始化
void STInit(ST* pst)
{
	assert(pst);

	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

//栈的填入数据
void STPush(ST* pst, STDataType x)
{
	assert(pst);

	//检查容量
	if (pst->top == pst->capacity)
	{
		int newCapacity = pst->top == 0 ? 4 : pst->capacity * 2; //空栈申请4个元素，否则扩大一倍
		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType)); //开辟新容量个空间

		if (!tmp)
		{
			perror("realloc fail");
			return;
		}

		pst->a = tmp;
		pst->capacity = newCapacity;
	}

	//填入数据
	pst->a[pst->top++] = x; //在top位置填入数据
}

//栈的判空
bool STEmpty(ST* pst)
{
	return pst->top == 0; //比较运算符
}


//栈的删除数据
void STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	pst->top--;
}

//栈的栈顶元素访问
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	return pst->a[pst->top-1]; //栈顶没存放数据
}

//栈的大小计算
int STSize(ST* pst)
{
	assert(pst);

	return pst->top; //top正好和元素个数对应
}

//栈的销毁
void STDestroy(ST* pst)
{
	assert(pst);

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

创建队列

创建队列的本质是定义一个变量来维护一块内存，需要说明使用哪些成员记录队列的信息。

创建一个变量，需要做两个工作：第一分配内存，第二插入相应的数据。

typedef struct 
{
    ST stackPush;
    ST stackPop;
} MyQueue;

变量内存如下图所示：

创建队列：

MyQueue* myQueueCreate() 
{
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    if(!obj)
    {
        perror("malloc fail\n");
        return NULL; //null实质就是一个地址
    }

    //初始化队列
    STInit(&obj->stackPop);
    STInit(&obj->stackPush);

    return obj;
}

补充对NULL的理解：

A null-pointer constant is an integral constant expression that evaluates to zero (like 0 or 0L), or the cast of such value to type void* (like (void*)0).

值：空指针常量是求值为零的整型常量表达式(如0或0L)，或者将该值强制转换为类型void*(如(void*)0)。

A null pointer constant can be converted to any pointer type (or pointer-to-member type), which acquires a null pointer value. This is a special value that indicates that the pointer is not pointing to any object.

数据类型：NULL空指针常量可以转换为获取空指针值的任何指针类型(或指针到成员类型)。

指向位置：这是一个特殊值，表示指针没有指向任何对象。

插入元素

直接在插入栈中填入即可，不需要考虑边界情况

//将元素 x 推到队列的末尾
void myQueuePush(MyQueue* obj, int x) 
{
    assert(obj);
    STPush(&obj->stackPush, x);
}

返回队头元素

实质是返回栈底元素。如果删除栈中有元素，就直接返回删除栈的栈顶元素，否则先倒入插入栈中的数据，再返回。

int myQueuePeek(MyQueue* obj) 
{
    assert(obj);
    // assert(!myQueueEmpty(obj));
    
    //如果stackPop为空，先倒入，再返回
    if(STEmpty(&obj->stackPop))
    {
        //倒空stackPush
        while(!STEmpty(&obj->stackPush))
        {
            // int top = STTop(&obj->stackPush);
            STPush(&obj->stackPop, STTop(&obj->stackPush));
            STPop(&obj->stackPush);
        }        
    }

    return STTop(&obj->stackPop);
}

移除并返回队头元素

先返回队头元素，再删除队头元素。

int myQueuePop(MyQueue* obj) 
{
    int top = myQueuePeek(obj); //保存队头元素
    STPop(&obj->stackPop);
    return top;
}

判空队列

如果队列为空，返回 true ；否则，返回 false

bool myQueueEmpty(MyQueue* obj) 
{
    return STEmpty(&obj->stackPush) 
        && STEmpty(&obj->stackPop);
}

销毁队列

先销毁栈，再销毁队列。因为栈和队列分别指向一块堆内存，仅销毁栈队列，便会造成内存泄漏。

void myQueueFree(MyQueue* obj) 
{
    STDestroy(&obj->stackPop);
    STDestroy(&obj->stackPush);
    
    free(obj);
}

完整代码

//创建栈结构
typedef int STDataType;
typedef struct Stack
{
	int top; //指向栈顶元素的下一个位置
	int capacity;
	STDataType* a; //动态数组
} ST;

//实现栈的函数
//栈的初始化
void STInit(ST* pst);

//栈的填入数据
void STPush(ST* pst, STDataType x);

//栈的删除数据
void STPop(ST* pst);

//栈的判空
bool STEmpty(ST* pst);

//栈的栈顶元素访问
STDataType STTop(ST* pst);

//栈的大小计算
int STSize(ST* pst);

//栈的销毁
void STDestroy(ST* pst);


// #include "Stack.h"

//实现栈的函数
//栈的初始化
//内容：开辟动态数组、栈顶、容量
void STInit(ST* pst)
{
	assert(pst);

	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

//栈的填入数据
void STPush(ST* pst, STDataType x)
{
	assert(pst);

	//检查容量
	if (pst->top == pst->capacity)
	{
		int newCapacity = pst->top == 0 ? 4 : pst->capacity * 2; //空栈申请4个元素，否则扩大一倍
		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType)); //开辟新容量个空间

		if (!tmp)
		{
			perror("realloc fail");
			return;
		}

		pst->a = tmp;
		pst->capacity = newCapacity;
	}

	//填入数据
	pst->a[pst->top++] = x; //在top位置填入数据
}

//栈的判空
bool STEmpty(ST* pst)
{
	return pst->top == 0; //比较运算符
}


//栈的删除数据
void STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	pst->top--;
}

//栈的栈顶元素访问
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	return pst->a[pst->top-1]; //栈顶没存放数据
}

//栈的大小计算
int STSize(ST* pst)
{
	assert(pst);

	return pst->top; //top正好和元素个数对应
}

//栈的销毁
void STDestroy(ST* pst)
{
	assert(pst);

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


//创建栈实现队列
//包含两个栈即可，不需要再做额外说明
typedef struct 
{
    ST stackPush;
    ST stackPop;
} MyQueue;

//定义队列结构
//创建东西，就是分配内存，插入数据才意义
MyQueue* myQueueCreate() 
{
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    if(!obj)
    {
        perror("malloc fail\n");
        return NULL; //null实质就是一个地址
    }

    //初始化队列
    STInit(&obj->stackPop);
    STInit(&obj->stackPush);

    return obj;
}

//将元素 x 推到队列的末尾
void myQueuePush(MyQueue* obj, int x) 
{
    assert(obj);
    // assert(!ST(obj));
    STPush(&obj->stackPush, x);
}

//返回栈顶并删除
// int popTop(MyQueue* obj)
// {
//     int top = STTop(&obj->stackPop);
//     STPop(&obj->stackPop);
//     return top;
// }

//返回队列开头的元素
int myQueuePeek(MyQueue* obj) 
{
    assert(obj);
    // assert(!myQueueEmpty(obj));
    
    //如果stackPop为空，先倒入，再返回
    if(STEmpty(&obj->stackPop))
    {
        //倒空stackPush
        while(!STEmpty(&obj->stackPush))
        {
            // int top = STTop(&obj->stackPush);
            STPush(&obj->stackPop, STTop(&obj->stackPush));
            STPop(&obj->stackPush);
        }        
    }

    return STTop(&obj->stackPop);
}


//从队列的开头移除并返回元素
int myQueuePop(MyQueue* obj) 
{
    int top = myQueuePeek(obj);
    STPop(&obj->stackPop);
    return top;
}

// 如果队列为空，返回 true ；否则，返回 false
bool myQueueEmpty(MyQueue* obj) 
{
    return STEmpty(&obj->stackPush) && STEmpty(&obj->stackPop);
}

//销毁内存
void myQueueFree(MyQueue* obj) 
{
    // free((&obj->stackPop)->a);
    // free((&obj->stackPush)->a);

    STDestroy(&obj->stackPop);
    STDestroy(&obj->stackPush);
    
    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);
*/

总结

  • 实现一种数据结构需要说明内存的管理方式和数据的访问规则。

  • 对于本题而言，队列元素的访问是遵循“先进先出”的规则，并且只能在队头取出数据，在队尾存入数据。

  • 用栈实现意味着队列元素是存放在数组中，一块连续的内存中，并且还要遵守栈元素的访问规则。

  • 队头元素在栈底，就只能使得队头元素成为栈顶元素才能在栈中访问。

  • 创建一个变量，需要做两个工作：第一分配内存，第二插入相应的数据。

戴冠承重
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
两个栈模拟实现队列
m0_63020222的博客
03-23 8809
用两个栈模拟实现队列
[数据结构] 用两个栈实现队列详解
weixin_67596609的博客
03-22 3638
在数据结构中，栈和队列是较为常见的两种数据结构。。那怎么用栈去实现队列呢？此问题在面试中也是高频出现的问题。本篇文章会给出详细解释。
经典面试题之-用两个栈实现一个队列（超详细！简单易懂！）
最新发布
yzc的博客
04-22 1219
经典面试题-用两个栈实现队列详解（超详细！简单易懂）看不懂打死我!
栈实现队列
Z___R的博客
10-22 88
题目描述 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 1、Javascript解法 var stack1=[]; var stack2 = []; function push(node) { // write code here stack1.push(node); } function pop() { // write code here if (stack2.length===0){ while(stack
两个栈模拟队列
qq_58724706的博客
11-03 801
目录 题目描述 题目解析 总结： 结构体初始化 函数接口 MyQueue* myQueueCreate() void myQueuePush(MyQueue* obj, int x) int myQueuePop(MyQueue* obj) int myQueuePeek(MyQueue* obj) bool myQueueEmpty(MyQueue* obj) void myQueueFree(MyQueue* obj) 完整代码 题目描述 请你仅使用两个栈实现先入先出队列.
两个队列模拟实现栈
m0_63020222的博客
03-25 5481
用两个队列模拟实现栈
栈和队列操作：栈实现、队列实现、双栈实现队列、双队列实现栈、栈实现O(n)求当前栈最大值
12-18
栈实现 队列实现 双栈实现队列 双队列实现栈 栈实现O(n)求当前栈最大值 http://blog.csdn.net/ssuchange/article/details/17398007
双栈实现队列C实现代码
02-10
使用双栈实现的队列，含有如下功能： 1.创建队列； 2.销毁队列； 3.清空队列； 4.进队列； 5.出队列； 6.获取队头元素； 7.获取队列的长度。
如何使用两个栈实现队列Java
08-25
主要介绍了如何使用两个栈实现队列Java,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
栈、队列实现停车场管理系统 模拟程序
03-28
设停车场是一个可停放n辆汽车的狭长通道,且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序,依次由北向南排列(大门在最南端,最先到达的第一辆车...试为停车场编制按上述要求进行管理的模拟程序。
JS实现利用两个队列表示一个栈的方法
11-27
本文实例讲述了JS实现利用两个队列表示一个栈的方法。分享给大家供大家参考，具体如下： 先看原理图： 理清楚思路，再动笔写： <!DOCTYPE html> <html> <head> <title>2 Queue</title&gt...
【用两个栈实现队列】队列的概念+使用栈实现队列，存在易错点
m0_48086806的博客
05-31 114
【代码】【用两个栈实现队列】队列的概念+使用栈实现队列，存在易错点。
【数据结构】用栈实现队列
Extreme_wei的博客
03-25 2612
本篇总结利用栈如何实现队列的相关操作，不难观察，栈和队列是可以相互转化的，需要好好总结它们的特性，构造出一个恰当的结构来实现即可，所以本篇难点不在代码思维，而是对结构的理解。
[数据结构] 用两个队列实现栈详解
weixin_67596609的博客
03-25 2499
​我们上篇文章讲述了用两个栈实现队列，用过对上篇文章的学习后，我们再去学用两个队列实现栈就变得相对来说容易了很多。本篇文章会对用两个队列实现栈进行详解，希望会对你有所帮助。
双栈模拟队列
dingyi5625的博客
09-11 162
双栈模拟队列 利用两个栈 S1、S2 模拟一个队列(如客户队列)时，如何用栈的运算实现队列的插入、 删除运算。使用算法描述。 思路： 输入：s1负责 若s1非空，则直接输进s1。 若s1满，则检查s2是否为空。 若为空将s1元素反向置入s2中。若非空则失败（非空不能插入元素，否则破坏顺序） 输出：s2负责 若s2非空，则直接输出一个元素。...
用两个栈来实现队列
Youga123的专栏
09-03 402
Python中两个栈实现队列
两个栈模拟一个队列、两个队列模拟一个栈
weixin_73231980的博客
09-25 1093
1、两个栈模拟一个队列 2、两个队列模拟一个栈
栈和队列经典算法 —— 双栈实现队列与双队列实现栈
云杉木屋
07-14 1874
摘要：栈和队列是数据结构中经典且重要的两个成员，我们在学习完线性表之后接触的最早两个数据结构就是这两个，关于这两个数据结构的算法也是非常多且重要，最重要的是这两个算法 —— 两个栈实现一个队列和两个队列实现一个栈。...
用c语言写双栈实现队列功能的算法
03-09
可以使用两个栈来实现队列的功能。一个栈用于入队，另一个栈用于出队。具体实现如下： 1. 定义两个栈stack1和stack2，stack1用于入队，stack2用于出队。 2. 入队操作：将元素压入stack1中。 3. 出队操作：如果stack...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值