26-队列练习-LeetCode225用队列实现栈
Posted hyperNZ
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了26-队列练习-LeetCode225用队列实现栈相关的知识，希望对你有一定的参考价值。
题目
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
注意：
你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作可。
示例：
输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]
解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False
提示：
1 <= x <= 9
最多调用100 次 push、pop、top 和 empty
每次调用 pop 和 top 都保证栈不为空
进阶：你能否仅用一个队列来实现栈。
思路1：用2个队列实现一个栈：
- q1队列：添加元素之后存储具体元素的队列。
- q2队列：作为辅助队列，每次添加元素之后保证q2为空。
元素先入q2，然后将q1的元素出队再入q2，再让q1与q2互换名字。
代码1
class MyStack
//q1永远是保存元素的队列
private Queue<Integer> queue1;
//q2永远保持为空，为辅助队列
private Queue<Integer> queue2;
public MyStack()
this.queue1 = new LinkedList<>();
this.queue2 = new LinkedList<>();
public void push(int x)
queue2.offer(x);
//将q1的所有元素依次出队列而后入q2
while(!queue1.isEmpty())
queue2.offer(queue1.poll());
//此时q1为空，q2存元素，q1与q2互换名字
Queue<Integer> tmp = queue1;
queue1 = queue2;
queue2 = tmp;
public int pop()
return queue1.poll();
public int top()
return queue1.peek();
public boolean empty()
return queue1.isEmpty();
/**
* Your MyStack object will be instantiated and called as such:
* MyStack obj = new MyStack();
* obj.push(x);
* int param_2 = obj.pop();
* int param_3 = obj.top();
* boolean param_4 = obj.empty();
*/思路2：用一个队列实现一个栈
- 先获取当前队列中元素个数n
- 将元素入队
- 将队列中之前的n个元素出队
- 将出队的n个元素依次入队
（边出边入）
代码2
class MyStack
private Queue<Integer> queue;
public MyStack()
queue = new LinkedList<>();
public void push(int x)
//获取当前队列元素个数
int n = queue.size();
//先入队
queue.add(x);
//将前n个元素依次出队再入队
for(int i = 0; i < n; i++)
queue.add(queue.poll());
public int pop()
return queue.poll();
public int top()
return queue.peek();
public boolean empty()
return queue.isEmpty();
/**
* Your MyStack object will be instantiated and called as such:
* MyStack obj = new MyStack();
* obj.push(x);
* int param_2 = obj.pop();
* int param_3 = obj.top();
* boolean param_4 = obj.empty();
*/数据结构栈和队列OJ练习(栈和队列相互实现+循环队列实现)
目录
前言
前面在学习了栈和队列的实现之后，相信大家对栈和队列的结构和使用方式都有了一些理解。
下面我们就来进行一些练习，这这章的练习相对于原来在难度上有了一些提升。
原来的题只需要实现一个接口，而今天的练习题需要实现多个接口。
1.用队列实现栈
225. 用队列实现栈 - 力扣（LeetCode） (leetcode-cn.com)
栈：后进先出；队列：先进先出
方法：
创建两个队列，用来来回导数据。
入栈：将数据放入不为空的队列。
出栈：将不为空的队列中的数据以出队入栈的方式放入空队列，直到该队列中只剩一个数据。
这个数据就是要出栈的数据，直接将他pop掉即可。
栈顶：返回队尾。
检测栈是否为空：两个队列都为空，则栈为空。
口说无凭，请看图：
如图：
队列1中有4个数，以1，2，3，4顺序入队，所以1为队头，4为队尾。
根据队列先进先出规则，1应该先出队。而这里我们要实现栈，即后进先出，即应该先出队尾数据。
所以我们将除队尾数据全部先导入队列2中，这样队列1中就只剩下队尾数据。
注意：队列1中的数据导入队列2中后，数据的相对位置是不变的。
即：
最后出栈，就可得到栈顶数据。
代码如下：
typedef int QDataType;
typedef struct QueueNode
{
struct QueueNode* next;
QDataType data;
}QueueNode;
typedef struct Queue
{
QueueNode* head;
QueueNode* tail;
}Queue;
//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestroy(Queue* pq);
//入队
void QueuePush(Queue* pq, QDataType x);
//出队
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);
//初始化
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
}
//销毁
void QueueDestroy(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->head;
while (cur)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
}
//入队
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (newnode == NULL)
{
perror("malloc");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
if (pq->head == NULL)
{
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
}
//出队
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
QueueNode* next = pq->head->next;
free(pq->head);
pq->head = next;
if (pq->head == NULL)
{
pq->tail = NULL;
}
}
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}
int QueueSize(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->head;
int size = 0;
while (cur)
{
size++;
cur = cur->next;
}
return size;
}
//因为C语言中没有直接可以调用的栈和队列，所以需要将自己实现的队列拷贝到前面
typedef struct {//在栈中创建两个队列
Queue q1;
Queue q2;
} MyStack;
bool myStackEmpty(MyStack* obj);
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))//入栈时向不为空的队列插入数据，都为空这里默认向队列2中插入
{
QueuePush(&obj->q1,x);
}
else
{
QueuePush(&obj->q2,x);
}
}
int myStackPop(MyStack* obj) {
Queue*empty = &obj->q1;//出栈时需在不为空的队列里出，所以先找不为空的队列
Queue*noempty = &obj->q2;//默认队列1不为空
if(!QueueEmpty(&obj->q1))//如果队列1不为空，则交换两队列
{
empty = &obj->q2;
noempty = &obj->q1;
}
while(QueueSize(noempty)>1)//将不为空队列中除队尾数据全部放入空队列中
{
QueuePush(empty,QueueFront(noempty));
QueuePop(noempty);
}
int pop = QueueFront(noempty);//剩下的最后一个数据
QueuePop(noempty);//将数据Pop掉
return pop;
}
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.用栈实现队列
232. 用栈实现队列 - 力扣（LeetCode） (leetcode-cn.com)
方法：
与上题类似，创建两个栈，将数据入栈与入队相同。栈1用来入数据，栈2用来出数据。
不过出队时，队头的数据位于栈底，所以还是要将除栈底的数据全部导入另一个栈中。
但不同的是，队列实现栈时，导过去后数据的顺序不变，所以需要来回导；而这里倒过去后数据顺序会颠倒，所以不需要再导回去，可以直接出队，直到该栈中没有数据。
口说无凭，请看图：
这样下一次再需要出队时，只需将栈2的栈顶Pop即可，直到栈2中没有数据，然后再从栈1中导数据。
代码如下：
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}Stack;
//初始化
void StackInit(Stack*ps);
//销毁
void StackDestroy(Stack* ps);
//压栈
void StackPush(Stack* ps, STDataType x);
//出栈
void StackPop(Stack* ps);
//栈顶
STDataType StackTop(Stack* ps);
//判断栈是否为空
bool StackEmpty(Stack* ps);
//栈中元素个数
int StackSize(Stack* ps);
void StackInit(Stack* ps)
{
assert(ps);
ps->a = NULL;
ps->capacity = 0;
ps->top = 0;
}
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}
void StackPush(Stack* ps, STDataType x)
{
assert(ps);
if (ps->top == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a , sizeof(STDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc");
exit(-1);
}
ps->a = tmp;
ps->capacity = newcapacity;
}
ps->a[ps->top] = x;
ps->top++;
}
void StackPop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
ps->top--;
}
STDataType StackTop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
bool StackEmpty(Stack* ps)
{
assert(ps);
return ps->top == 0;
}
int StackSize(Stack* ps)
{
assert(ps);
return ps->top;
}
//同样需拷贝自己实现的栈
typedef struct {//创建两个栈，s1用来入数据，s2用来出数据
Stack s1;
Stack s2;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue*obj = (MyQueue*)malloc(sizeof(MyQueue));
StackInit(&obj->s1);
StackInit(&obj->s2);
return obj;
}
void myQueuePush(MyQueue* obj, int x) {
StackPush(&obj->s1,x);//直接将数据Push到s1中
}
int myQueuePop(MyQueue* obj) {
if(StackEmpty(&obj->s2))//pop数据之前先检查s2中是否有数据，没有数据需从s1中导入
{
while(!StackEmpty(&obj->s1))
{
StackPush(&obj->s2,StackTop(&obj->s1));
StackPop(&obj->s1);
}
}
int pop = StackTop(&obj->s2);//直接pop栈顶数据即可
StackPop(&obj->s2);
return pop;
}
int myQueuePeek(MyQueue* obj) {//返回队尾数据(即s2栈顶数据)
if(StackEmpty(&obj->s2))//返回数据之前先检查s2中是否有数据，没有数据需从s1中导入
{
while(!StackEmpty(&obj->s1))
{
StackPush(&obj->s2,StackTop(&obj->s1));
StackPop(&obj->s1);
}
}
return StackTop(&obj->s2);
}
bool myQueueEmpty(MyQueue* obj) {//两个栈都为空，队列才为空
return StackEmpty(&obj->s1)&&StackEmpty(&obj->s2);
}
void myQueueFree(MyQueue* obj) {
StackDestroy(&obj->s1);
StackDestroy(&obj->s2);
free(obj);
}3.循环队列
622. 设计循环队列 - 力扣（LeetCode） (leetcode-cn.com)
这道题的意思是：
设计一个队列，这个队列的大小是固定的，且队列头尾相连， 然后该队列能够实现题目中的操作。
那么是使用数组实现，还是用链表实现呢？我们接着往下看。
例如：用k表示数组大小
图中我们用数组实现。用head和tail表示队头队尾下标，每插入一个数据，在数组tail位置插入，然后再将tail++。
但是有个问题如果将head==tail认为是队列为空的条件，那么怎么判断队列满了呢？
面对这个问题我们这样解决：将数组的空间大小增加1，即数组比队列大1个空间。
这样：当 head = tail 时队列为空，(tail+1)%(k+1) = head 时队列满了。
且以链表实现时也会多申请一个空间。
代码如下：数组实现。
typedef struct {
int*arr;
int head;//队头
int tail;//队尾
int capacity;//队列容量
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue*obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
obj->arr = (int*)malloc(sizeof(int)*(k+1));//申请数组空间
obj->head = 0;
obj->tail = 0;
obj->capacity = k;//队列大小
return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);
//插入数据
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if(myCircularQueueIsFull(obj))//检查容量
{
return false;
}
else
{
obj->arr[obj->tail] = value;//在队尾位置插入
obj->tail++;//队尾向后移动
obj->tail %= obj->capacity+1;//当队尾移动到数组最后一个元素后面的下标时，队尾回到数组下标为0的位置
return true;
}
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))//检测队列是否为空
{
return false;
}
else
{
obj->head++;
obj->head %= obj->capacity+1; 当队头移动到数组最后一个元素后面的下标时，队尾回到数组下标为0的位置
return true;
}
}
int myCircularQueueFront(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return -1;//队列为空返回-1
}
else
{
return obj->arr[obj->head];//返回队头数据
}
}
int myCircularQueueRear(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return -1;//队列为空返回-1
}
else
{
return obj->arr[(obj->tail+obj->capacity)%(obj->capacity+1)];//返回下标为tail位置前面一个位置数据
}
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->head == obj->tail;//head==tail队列为空
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return (obj->tail+1)%(obj->capacity+1) == obj->head;//为防止数组越界，不能直接将tail+1与head比较
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->arr);
free(obj);
}
链表实现与数组实现类似，只是判断队列满的条件的不一样。
链表判满的条件时tail->next = head;
代码如下：
typedef struct ListNode1 ListNode1;
struct ListNode1{
int data;
ListNode1* next;
};
typedef struct {
ListNode1* front;//创建头尾指针指向队列头和尾
ListNode1* tail;
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
obj->front = NULL;
ListNode1* cur = NULL;
while (k > -1)//创建k+1个结点
{
if (obj->front == NULL)
{
obj->front = (ListNode1*)malloc(sizeof(ListNode1));
obj->front->next = NULL;
cur = obj->front;
}
else
{
ListNode1* next = (ListNode1*)malloc(sizeof(ListNode1));
cur->next = next;
cur = next;
}
k--;
}
cur->next = obj->front;//将链表成环
obj->tail = obj->front;//头尾指针复位
return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if (myCircularQueueIsFull(obj))
{
return false;
}
else
{
obj->tail->data = value;//插入数据将数据放入tail结点
obj->tail = obj->tail->next;//tail结点向后移动
return true;
}
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj))
{
return false;
}
else
{
obj->front = obj->front->next;//删除数据时直接将头指针向后移动，不用将该位置的数据删除
return true;
}
}
int myCircularQueueFront(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj))
{
return -1;
}
else
{
return obj->front->data;//返回头指针结点处的数据
}
}
int myCircularQueueRear(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj))
{
return -1;
}
else
{
ListNode1* cur = obj->front;//因为不知到队尾位置，只知道队尾的下一个位置，所以需要遍历链表寻找队尾。
while (cur->next != obj->tail)
{
cur = cur->next;
}
return cur->data;
}
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->front == obj->tail;//head==tail队列为空
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return obj->tail->next == obj->front;//tail->next == head 队列满了
}
void myCircularQueueFree(MyCircularQueue* obj) {
ListNode1* cur = obj->front->next;
while (cur != obj->front)//释放链表结点
{
ListNode1* next = cur->next;
free(cur);
cur = next;
}
free(cur);
free(obj);
}如有错误，或更好的方法，可以在评论区一起交流哟~
你的点赞支持就是我创作的动力！
以上是关于26-队列练习-LeetCode225用队列实现栈的主要内容，如果未能解决你的问题，请参考以下文章
LeetCode Algorithm 225. 用队列实现栈