232. 用栈实现队列

已于 2023-04-14 17:41:56 修改
阅读量276 收藏 4
点赞数 12
文章标签： 数据结构 算法
于 2023-03-16 23:00:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73345579/article/details/129569209
版权

1.题目：

2.思路：

此题可以用两个栈实现，一个栈进行入队操作，另一个栈进行出队操作

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

3.我的代码：

C语言：

typedef int STDataType;     //重定义数据类型
typedef struct Stack
{
	STDataType* data;
	int top;                //栈顶
	int capacity;           //容量
}Stack;

extern void StackInit(Stack* ps);                         // 1.初始化栈 

extern void StackPush(Stack* ps, STDataType x);           // 2.入栈 

extern void StackPop(Stack* ps);                          // 3.出栈 

extern STDataType StackTop(Stack* ps);                    // 4.获取栈顶元素 

extern int StackSize(Stack* ps);                          // 5.获取栈中有效元素个数 

extern bool StackEmpty(Stack* ps);                        // 6.检测栈是否为空

extern void StackDestroy(Stack* ps);                      // 7.销毁栈 

void StackInit(Stack* ps)     // 1.初始化栈 
{
	assert(ps);

	ps->data = NULL;
	ps->capacity = 0;
	ps->top = 0;     //初始值是－1或0都可以，但是初始值不同，后期的操作不同

}

void StackPush(Stack* ps, STDataType x)     // 2.入栈 
{
	assert(ps);

	if (ps->capacity == ps->top)     //扩容
	{
		int newcapacity = ps->capacity > 0 ? 2 * ps->capacity : 4;     //考虑容量为0的情况
		STDataType* tmp = (STDataType*)realloc(ps->data, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)     //考虑扩容失败
		{
			perror("realloc:");
			return;
		}
		ps->data = tmp;
		ps->capacity = newcapacity;
	}

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

void StackPop(Stack* ps)     // 3.出栈
{
	assert(ps);
	assert(!StackEmpty(ps));     //考虑栈空

	ps->top--;
}

STDataType StackTop(Stack* ps)     // 4.获取栈顶元素 
{
	assert(ps);
	assert(!StackEmpty(ps));     //考虑栈空

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

int StackSize(Stack* ps)     // 5.获取栈中有效元素个数 
{
	assert(ps);

	return ps->top;
}

bool StackEmpty(Stack* ps)         // 6.检测栈是否为空
{
	assert(ps);

	return ps->top == 0;
}

void StackDestroy(Stack* ps)     // 7.销毁栈 
{
	assert(ps);

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

typedef struct 
{
    Stack stpush;     //使用两个栈模拟实现队列
    Stack stpop;      //一个栈入数据，另一个出数据
} MyQueue;


MyQueue* myQueueCreate() 
{
    MyQueue* myQueue = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&myQueue->stpush);
    StackInit(&myQueue->stpop);
    return myQueue;
}

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

int myQueuePop(MyQueue* obj) 
{
    if (StackEmpty(&obj->stpop))     //判断出数据栈是否为空
    {
        while (!StackEmpty(&obj->stpush))     //将入数据栈的数据压入出数据栈
        {
            StackPush(&obj->stpop, StackTop(&obj->stpush));
            StackPop(&obj->stpush);
        }
    }

    int ret = StackTop(&obj->stpop);
    StackPop(&obj->stpop);     //出数据
    return ret;
}

int myQueuePeek(MyQueue* obj) 
{
    if (StackEmpty(&obj->stpop))     //判断出数据栈是否为空
    {
        while (!StackEmpty(&obj->stpush))     //将入数据栈的数据压入出数据栈
        {
            StackPush(&obj->stpop, StackTop(&obj->stpush));
            StackPop(&obj->stpush);
        }
    }
    return StackTop(&obj->stpop);
}

bool myQueueEmpty(MyQueue* obj) 
{
    return StackEmpty(&obj->stpush) && StackEmpty(&obj->stpop);
}

void myQueueFree(MyQueue* obj) 
{
    StackDestroy(&obj->stpush);
    StackDestroy(&obj->stpop);
    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);
*/

Java：

class MyQueue {

    private Stack<Integer> pushStack;
    private Stack<Integer> popStack;

    public MyQueue() {
        pushStack = new Stack<>();
        popStack = new Stack<>();
    }
    
    public void push(int x) {
        pushStack.push(x);
    }
    
    public int pop() {
        if (empty()) {
            return -1;
        }

        if (popStack.isEmpty()) {
            int size = pushStack.size();
            for (int i = 0; i < size; ++i) {
                int tmp = pushStack.pop();
                popStack.push(tmp);
            }
        }
            
        return popStack.pop();
    }
    
    public int peek() {
        if (empty()) {
            return -1;
        }

        if (popStack.isEmpty()) {
            int size = pushStack.size();
            for (int i = 0; i < size; ++i) {
                int tmp = pushStack.pop();
                popStack.push(tmp);
            }
        }
            
        return popStack.peek();
    }
    
    public boolean empty() {
        return popStack.isEmpty() && pushStack.isEmpty();
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

 

4.答案代码：

C语言：

typedef int STDataType;     //重定义数据类型
typedef struct Stack
{
	STDataType* data;
	int top;                //栈顶
	int capacity;           //容量
}Stack;

extern void StackInit(Stack* ps);                         // 1.初始化栈 

extern void StackPush(Stack* ps, STDataType x);           // 2.入栈 

extern void StackPop(Stack* ps);                          // 3.出栈 

extern STDataType StackTop(Stack* ps);                    // 4.获取栈顶元素 

extern int StackSize(Stack* ps);                          // 5.获取栈中有效元素个数 

extern bool StackEmpty(Stack* ps);                        // 6.检测栈是否为空

extern void StackDestroy(Stack* ps);                      // 7.销毁栈 

void StackInit(Stack* ps)     // 1.初始化栈 
{
	assert(ps);

	ps->data = NULL;
	ps->capacity = 0;
	ps->top = 0;     //初始值是－1或0都可以，但是初始值不同，后期的操作不同

}

void StackPush(Stack* ps, STDataType x)     // 2.入栈 
{
	assert(ps);

	if (ps->capacity == ps->top)     //扩容
	{
		int newcapacity = ps->capacity > 0 ? 2 * ps->capacity : 4;     //考虑容量为0的情况
		STDataType* tmp = (STDataType*)realloc(ps->data, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)     //考虑扩容失败
		{
			perror("realloc:");
			return;
		}
		ps->data = tmp;
		ps->capacity = newcapacity;
	}

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

void StackPop(Stack* ps)     // 3.出栈
{
	assert(ps);
	assert(!StackEmpty(ps));     //考虑栈空

	ps->top--;
}

STDataType StackTop(Stack* ps)     // 4.获取栈顶元素 
{
	assert(ps);
	assert(!StackEmpty(ps));     //考虑栈空

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

int StackSize(Stack* ps)     // 5.获取栈中有效元素个数 
{
	assert(ps);

	return ps->top;
}

bool StackEmpty(Stack* ps)         // 6.检测栈是否为空
{
	assert(ps);

	return ps->top == 0;
}

void StackDestroy(Stack* ps)     // 7.销毁栈 
{
	assert(ps);

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

typedef struct {
    //入队栈
    Stack pushST;
    //出队栈
    Stack popST;
} MyQueue;
 
/** Initialize your data structure here. */
MyQueue* myQueueCreate(int maxSize) {
    MyQueue* pqueue = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&pqueue->pushST, maxSize);
    StackInit(&pqueue->popST, maxSize);
    return pqueue;
}
 
/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
    //入队栈进行入栈操作
    StackPush(&obj->pushST, x);
}
 
/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
    //如果出队栈为空，导入入队栈的元素
    if(StackEmpty(&obj->popST) == 0)
    {
        while(StackEmpty(&obj->pushST) != 0)
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    
    int front = StackTop(&obj->popST);
    //出队栈进行出队操作
    StackPop(&obj->popST);
    return front;
}
 
/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
    //类似于出队操作
    if(StackEmpty(&obj->popST) == 0)
    {
        while(StackEmpty(&obj->pushST) != 0)
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    
    return StackTop(&obj->popST);
}
 
/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST) == 0
        &&  StackEmpty(&obj->popST) == 0;
}
 
void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    
    free(obj);
}

Java：

/*
    解题思路：
     利用两个栈模拟实现队列
     入队列：s1模拟入队列，所有入队列的元素都放入到s1中
     出队列：s2模拟出队列，当s2为空时，将s1中所有元素导入到s2中
            s2中pop一个元素
     获取队头元素：如果s2是空，将s1中所有元素导入s2中，然后peek()一个元素
 */
class MyQueue {
    private Stack<Integer> s1;  // 模拟入队列，所有元素都放入到s1中
    private Stack<Integer> s2;
    public MyQueue() {
        s1 = new Stack<>();
        s2 = new Stack<>();
    }
    
    // 入队类时，直接找s1
    public void push(int x) {
        s1.push(x);
    }
    
    // 出队列：如果s2是空的，需要将s1中的所有元素导入到s2中
    // 此时s1先压入的元素就后进入到s2中，出的时候就先出了
    public int pop() {
        if(s2.empty()){
            while(!s1.empty()){
                s2.push(s1.pop());
            }
        }
        return s2.pop();
    }
    
    public int peek() {
        if(s2.empty()){
            while(!s1.empty()){
                s2.push(s1.pop());
            }
        }
        return s2.peek();
    }
    
    public boolean empty() {
        return s1.empty() && s2.empty();
    }
}

数九天有一个秘密
关注
  • 12
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
如何使用两个栈实现队列Java
08-25
这种实现方法虽然在pop操作时可能会有额外的时间开销（如果栈2为空，需要转移所有元素），但在某些情况下，如空间限制或特定应用场景下，使用两个栈实现队列可能比直接使用Java提供的Queue接口更具优势，因为它避免...
python入门-leetcode面试题解之第232题用栈实现队列.zip
最新发布
05-31
本教程聚焦于"python入门-leetcode面试题解之第232题用栈实现队列"，旨在帮助初学者理解如何利用栈（Stack）这一数据结构来实现队列（Queue）的功能。LeetCode是一个广受欢迎的在线平台，它提供了丰富的编程挑战，...
Java实现 LeetCode 232 用栈实现队列
热门推荐
南 墙
02-29 1万+
232. 用栈实现队列 使用栈实现队列的下列操作： push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 que...
【leetcode 简单】 第六十六题 用栈实现队列
weixin_30715523的博客
08-24 252
使用栈实现队列的下列操作： push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); ...
232.用栈实现队列
weixin_46009158的博客
04-28 140
题目: 使用栈实现队列的下列操作： push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/implement-queue-using-stacks 思路: 使用两个栈的思路来实现队列...
java-leetcode面试题解Stack之第232题用栈实现队列-题解.zip
05-05
本题解聚焦于LeetCode中的第232题——"用栈实现队列"，这是一个常见的数据结构问题，尤其在面试中常常被问到，因为它考察了对栈（Stack）和队列（Queue）基本概念的理解以及如何创造性地运用它们。 首先，我们来...
python用栈实现队列
05-30
python用栈实现队列，简单明了易于进一步思考和总结发散思维。
zhanheduilie.rar_栈和队列
09-24
总之，栈和队列是编程中不可或缺的数据结构，深入理解其原理并掌握其使用方法，将对软件开发和问题解决带来极大帮助。通过阅读"zhanheduilie.ppt"这份资料，你将能够系统学习到栈和队列的各个方面，并在实际项目中...
LebronAl#myLeetcodeDailyRecord#232_用栈实现队列1
07-25
题目使用栈实现队列的下列操作：push(x) -- 将一个元素放入队列的尾部。需要注意的是 Java 的 Stack 是基于数组实现的，频繁增删性能较低，可以直
如何使用JavaScript实现栈与队列
10-16
在JavaScript中，可以使用数组来简单实现队列： ```javascript function Queue() { this.items = []; } Queue.prototype.enqueue = function(item) { this.items.push(item); }; Queue.prototype.dequeue = ...
Java实现栈和队列面试题
09-03
同样，可以使用链表来实现队列。创建一个`Queue`类，`add()`方法用于入队，如果队列为空，则新节点成为头节点；否则，新节点连接到当前节点的末尾。`pop()`方法用于出队，返回头节点的数据并更新头节点为下一个节点...
02-栈和队列.zip
01-31
栈与队列.pptx可能是课程的幻灯片，详细地展示了这两个数据结构的特性、操作以及相关算法的实现。幻灯片可能包含示例代码、图解和习题。 作业.txt可能包含了一些练习题目，要求学生实践栈和队列的操作，或者解决...
用栈实现队列(java代码).docx
02-21
### 使用两个栈实现队列（Java代码） #### 一、问题背景 在计算机科学中，队列是一种重要的数据结构，遵循先进先出（FIFO）原则。而在实际应用中，有时候我们可能没有现成的队列类或者接口可用，这时就需要通过...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

数九天有一个秘密

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

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

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

打赏作者

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

抵扣说明：

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

余额充值