题目
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、empty):
实现 MyQueue 类:
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空,返回 true ;否则,返回 false
来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/implement-queue-using-stacks
核心思路
栈的特点是先进后出,队列的特点是先进先出
1.自己实现栈
2.用两个栈实现队列
3.入列时,两个栈一个是输出栈,一个是输入栈,入列时把数据向输入栈插入
4.出列时,把输出栈的栈顶数据删除,如果输出栈没有数据,就将输入栈的全部数据移动到输出栈里面
5.返回对头数据时,要将输出栈的栈顶数据返回,如果输出栈没有数据,就将输入栈的全部数据移动到输出栈中
6.判断队列为不为空时,只有两个栈皆空队列才为空
细节
这里肯定就会有人不明白,输出栈的栈顶数据为什么就是对头的数据,为什么和两队列实现栈不同
开始移动数据到输出栈
这时我们会惊奇的发现数据的顺序就是我们想要的顺序,队列的特点是先进先出因为我们插入的顺序是1,2,3,4所以输出的顺序也应该是1,2,3,4,看图我们又发现输出栈栈顶到栈底的数据顺序也是1,2,3,4。
再入列时
再出列
注意只有输出栈为空时才能把输入栈的数据移动到输出栈上
代码
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int capacity;
int top;
}ST;
void StackInit(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);
void StackDestroy(ST* ps);
STDataType StackTop(ST* ps);
int StackSize(ST* ps);
bool StackEmpty(ST* ps);
void StackInit(ST* ps)
{
ps->a = NULL;
ps->capacity = 0;
ps->top = 0;
}
void StackPush(ST* ps, STDataType x)
{
if (ps->top == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* pf = realloc(ps->a, sizeof(STDataType) * newcapacity);
if (pf == NULL)
{
printf("realloc fail");
exit(-1);
}
ps->a = pf;
ps->capacity = newcapacity;
}
ps->a[ps->top] = x;
ps->top++;
}
void StackPop(ST* ps)
{
assert(ps);
assert(ps->top > 0);
ps->top--;
}
void StackDestroy(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = 0;
ps->top = 0;
}
STDataType StackTop(ST* ps)
{
assert(ps);
assert(ps->top != 0);
return ps->a[ps->top - 1];
}
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
bool StackEmpty(ST* ps)
{
assert(ps);
if (ps->top == 0)
{
return true;
}
else
{
return false;
}
}
//以上代码为栈的实现
typedef struct
{
ST PushST;
ST PopST;
} MyQueue;
MyQueue* myQueueCreate()
{
MyQueue* Queue = (MyQueue*)malloc(sizeof(MyQueue));
StackInit(&Queue->PushST);
StackInit(&Queue->PopST);
return Queue;
}
void myQueuePush(MyQueue* obj, int x)
{
StackPush(&obj->PushST, x);
}
int myQueuePop(MyQueue* obj)
{
if (StackEmpty(&obj->PopST))
{
while (!StackEmpty(&obj->PushST))
{
StackPush(&obj->PopST, StackTop(&obj->PushST));
StackPop(&obj->PushST);
}
}
int top = StackTop(&obj->PopST);
StackPop(&obj->PopST);
return top;
}
int myQueuePeek(MyQueue* obj)
{
if (StackEmpty(&obj->PopST))
{
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);
}