【LeetCode】【牛客】栈和队列刷题（C语言实现）
目录
一、设计循环队列
二、用栈实现队列
C++版本
三、用队列实现栈
C++版本
一、设计循环队列
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
你的实现应该支持如下操作：
MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。
来源：力扣（LeetCode）
链接：力扣
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//定义我们的循环列表的结构体类型，用a来表示一个数组
//k表示我们循环链表存储的最大元素个数
//head指针来表示我们的头指针
//tail指针来表示我们的尾指针
typedef struct {
int* a;
int k;
int head;
int tail;
} MyCircularQueue;
//创建我们的循环链表
MyCircularQueue* myCircularQueueCreate(int k) {
//开辟一块循环链表的空间来存储我们的循环链表
MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
//给我们的a数列开辟一块k+1大小的空间来存储我们的数组
//我们这里为什么要将我们的空间指定为k+1呢？
//应为如果我们的尾指针指向的是我们的队尾的结点元素
//（我们循环链表初始化的时候头尾指针指向的都是同一个结点，
//而我们的循环链表中的元素填满时，
//再要往我们的循环链表中添加元素的时候我们就不知道当前的链表是满了还是空的）
//所以我们在这里将我们的尾指针指向的空间为尾结点的下一个结点
//这样当我们的循环队列为空的时候，我们的队首指针和队尾指针指向的是同一块空间。
//而当我们的循环队列空间被填满的时候，我们的队尾指针的后一个地址为我们的队首指针
obj->a=malloc(sizeof(int)*(k+1));
//将我们的队首指针和队尾指针同时置空。
obj->head=obj->tail=0;
obj->k=k;
//将我们创建成功的循环列表的地址返回。
return obj;
}
//用于判断我们的循环队列是否为空，具体的判断条件在上面已经解释
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->head==obj->tail;
}
//判断我们的循环队列是不是已经满了，具体的判断条件在上面已经解释
bool myCircularQueueIsFull(MyCircularQueue* obj) {
int next=obj->tail+1;
if(next==obj->k+1)
next=0;
return next==obj->head;
}
//往我们的循环队列中插入元素，同时如果插入成功，则为返回true，如果插入失败，返回false。
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
//如果我们当前的队列已经满了，我们就返回false，表示加入元素失败
if(myCircularQueueIsFull(obj))
{
return false;
}
//如果我们的循环队列中还有空位置的话，我们就在我们tail的位置插入我们新的元素，然后将我们的tail指针后移
obj->a[obj->tail]=value;
obj->tail++;
//如果我们当前的队尾指针指向了k+1的位置，也就是我们的循环链表到了循环的结尾，我们需要将我们尾指针重新移动到队首，当然我们也可以用取模的方式来实现我们循环列表
if(obj->tail==obj->k+1)
{
obj->tail=0;
}
//如果代码能够走到此处，也就是说明我们的循环列表已经创建成功了。
return true;
}
//定义我们的出队操作
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
//如果我们的链表已经为空了，也就是不可能出队了，我们就返回false，也就是出队失败
if(myCircularQueueIsEmpty(obj))
{
return false;
}
//将我们的头指针后移，表示出队
++obj->head;
//如果我们的头指针已经到了k+1的位置，也就是超出了我们循环列表的范围，就将我们头指针重新指向队头，当然我们也可以使用取模的方法来实现我们循环列表的循环功能
if(obj->head==obj->k+1)
{
obj->head=0;
}
return true;
}
//输出我们的队首元素
int myCircularQueueFront(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return -1;
}
return obj->a[obj->head];
}
//输出我们的队尾元素。
int myCircularQueueRear(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return -1;
}
int prev=obj->tail-1;
if(obj->tail==0)
{
prev=obj->k;
}
return obj->a[prev];
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->a);
free(obj);
}
二、用栈实现队列
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
说明：你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
来源：力扣（LeetCode）
链接：力扣
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
由于我们在此是使用c语言来实现，所以我们需要手写一个栈。（可以参考以下博文）
栈的实现（c语言数据结构）_wolfwalker的博客-CSDN博客
本道题的主要思路，就是定义一个输入栈，一个输出栈，我们的数据输入全部都在输入栈，当数据需要输出时，由于我们需要获取栈底的元素，所以我们需要将我们输入栈中的元素全部倒入我们的输出栈中，从而获取到我们的栈底元素。
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);
void StackInit(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->top = 0;
ps->capacity = 0;
}
void StackDestroy(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->top = ps->capacity = 0;
}
void StackPush(ST* 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)
{
printf("realloc fail\n");
exit(-1);
}
ps->a = tmp;
ps->capacity = newCapacity;
}
ps->a[ps->top] = x;
ps->top++;
}
void StackPop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
ps->top--;
}
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
//定义我们的队列有一个入队指针pushst，和一个出队指针popst
typedef struct{
ST pushst;
ST popst;
}MyQueue;
//初始化我们的队列
MyQueue* myQueueCreate() {
MyQueue*obj=(MyQueue*)malloc(sizeof(MyQueue));
StackInit(&obj->pushst);
StackInit(&obj->popst);
return obj;
}
//队列的入队操作
void myQueuePush(MyQueue* obj, int x) {
StackPush(&obj->pushst,x);
}
//实现我们的出队操作
int myQueuePop(MyQueue* obj) {
if(StackEmpty(&obj->popst))
{
//如果pop栈为空，则把push栈的数据倒过来
while(!StackEmpty(&obj->pushst))
{
StackPush(&obj->popst,StackTop(&obj->pushst));
StackPop(&obj->pushst);
}
}
int front=StackTop(&obj->popst);
StackPop(&obj->popst);
return front;
}
//返回队列开头的元素，同样需要我们把输入栈的数据倒过来
int myQueuePeek(MyQueue* obj) {
if(StackEmpty(&obj->popst))
{
//如果pop栈为空，则把push栈的数据倒过来
while(!StackEmpty(&obj->pushst))
{
StackPush(&obj->popst,StackTop(&obj->pushst));
StackPop(&obj->pushst);
}
}
return StackTop(&obj->popst);
}
//队列判空，如果我们的输入栈和输出栈有一个为空，那我们的队列就是不空的
//如果我们的输入栈和输出栈都是空的，那我们的队列判空就是true
bool myQueueEmpty(MyQueue* obj) {
return StackEmpty(&obj->popst)&&StackEmpty(&obj->pushst);
}
//释放我们的队列空间，也就是释放我们的两个栈空间
void myQueueFree(MyQueue* obj) {
StackDestroy(&obj->pushst);
StackDestroy(&obj->popst);
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);
*/C++版本
class MyQueue {
public:
MyQueue() {
}
void push(int x) {
put_in.push(x);
}
int pop() {
if(take_out.empty())
{
while(!put_in.empty())
{
take_out.push(put_in.top());
put_in.pop();
}
int x=take_out.top();
take_out.pop();
return x;
}
else
{
int x=take_out.top();
take_out.pop();
return x;
}
}
int peek() {
if(take_out.empty())
{
while(!put_in.empty())
{
take_out.push(put_in.top());
put_in.pop();
}
}
return take_out.top();
}
bool empty() {
if(take_out.empty()&&put_in.empty())
{
return true;
}
return false;
}
private:
stack put_in;
stack take_out;
};
/**
* 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();
* bool param_4 = obj->empty();
*/ 三、用队列实现栈
请你仅使用两个队列实现一个后入先出（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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。来源：力扣（LeetCode）
链接：力扣
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
本道题我们需要使用队列来实现我们栈的功能，但由于我们当前是使用c语言写的，我们需要手动写一个队列出来，具体队列的写法可以参考下面的博文。
队列的实现（c语言数据结构）_wolfwalker的博客-CSDN博客
这道题我们的核心思想就是由于要用我们先入先出的队列实现我们先入后出的栈的功能，所以我们需要两个队列A和B，每次当有数据输入的时候，我们就先将数据存放到A队列中， 然后，当我们需要取出元素的时候，我们就将我们A队列中除了最后一个元素的其他元素全部都放入我们的队列B中，然后将我们A中，也就是那个最后的元素输出。然后依此规则进行迭代。此时如果再要取出元素，我们就需要将我们B队列中的元素除了最后一个全部都放入我们的A队列中，然后将我们B队列中那个仅剩的元素也就是我们当前的最后一个元素取出。
typedef int QDataType;
typedef struct QueueNode
{
QDataType data;
struct QueueNode* next;
}QNode;
typedef struct Queue
{
QNode* head;
QNode* tail;
//size_t size;
}Queue;
void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
bool QueueEmpty(Queue* pq);
size_t QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
//定义我们栈的类型，包含两个队列q1和q2
typedef struct {
Queue q1;
Queue q2;
} MyStack;
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
assert(pq);
QNode* cur = pq->head;
while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}
pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
assert(newnode);
newnode->data = x;
newnode->next = NULL;
if (pq->tail == NULL)
{
assert(pq->head == NULL);
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
}
void QueuePop(Queue* pq)
{
assert(pq);
assert(pq->head && pq->tail);
if (pq->head->next == NULL)
{
free(pq->head);
pq->head = pq->tail = NULL;
}
else
{
QNode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
//return pq->head == NULL && pq->tail == NULL;
return pq->head == NULL;
}
size_t QueueSize(Queue* pq)
{
assert(pq);
QNode* cur = pq->head;
size_t size = 0;
while (cur)
{
size++;
cur = cur->next;
}
return size;
}
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(pq->head);
return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(pq->tail);
return pq->tail->data;
}
//初始化我们的栈，需要我们将栈中的两个队列q1和q2初始化，同时将我们创建的栈的地址返回。
MyStack* myStackCreate() {
MyStack*obj=(MyStack*)malloc(sizeof(MyStack));
QueueInit(&obj->q1);
QueueInit(&obj->q2);
return obj;
}
//实现我们的入栈操作由于我们之前的思路，我们需要把我们的入栈的元素全部都放在一个栈中，
//另一个栈为空，所以当我们的q1是空的时候，我们就将我们的数据录入我们的q2队列，
//如果我们的q1不是空的话，我们就将我们的数据录入我们的q1队列
void myStackPush(MyStack* obj, int x) {
if(!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1,x);
}
else
{
QueuePush(&obj->q2,x);
}
}
//实现我们的出栈操作
int myStackPop(MyStack* obj) {
//创建两个指针分别指向q1和q2两个队列
Queue*emptyQ=&obj->q1;
Queue*nonEmptyQ=&obj->q2;
//如果我们的q1不是空的话，我们就交换我们的emptyQ与nonEmytyQ指针，
//nonEmytyQ也就是说不为空的意思
//emytyQ也就是为空的意思
if(!QueueEmpty(&obj->q1))
{
emptyQ=&obj->q2;
nonEmptyQ=&obj->q1;
}
//将我们的有元素的那个队列中的除了最后一个元素全部都放到我们另一个空的队列中
while(QueueSize(nonEmptyQ)>1)
{
QueuePush(emptyQ,QueueFront(nonEmptyQ));
QueuePop(nonEmptyQ);
}
//取出我们原先有元素的那个队列中的最后一个元素
int top=QueueFront(nonEmptyQ);
QueuePop(nonEmptyQ);
//将我们的栈底元素返回
return top;
}
//获取我们的栈顶元素
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) {
QueueDestory(&obj->q1);
QueueDestory(&obj->q2);
free(obj);
}
/**
* Your MyStack struct will be instantiated and called as such:
* MyStack* obj = myStackCreate();
* myStackPush(obj, x);
* int param_2 = myStackPop(obj);
* int param_3 = myStackTop(obj);
* bool param_4 = myStackEmpty(obj);
* myStackFree(obj);
*/C++版本
class MyStack {
public:
MyStack() {
}
void push(int x) {
if(qu1.empty())
{
qu2.push(x);
}
else if(qu2.empty())
{
qu1.push(x);
}
}
int pop() {
if(qu1.empty()&&qu2.empty())
{
return -1;
}
int result=-1;
if(qu1.empty())
{
while(qu2.size()>1)
{
qu1.push(qu2.front());
qu2.pop();
}
result=qu2.front();
qu2.pop();
}
else if(qu2.empty())
{
while(qu1.size()>1)
{
qu2.push(qu1.front());
qu1.pop();
}
result=qu1.front();
qu1.pop();
}
return result;
}
int top() {
int result=-1;
if(qu1.empty()&&qu2.empty())
{
return -1;
}
if(qu1.empty())
{
while(qu2.size()>1)
{
qu1.push(qu2.front());
qu2.pop();
}
result=qu2.front();
qu2.pop();
qu1.push(result);
}
else if(qu2.empty())
{
while(qu1.size()>1)
{
qu2.push(qu1.front());
qu1.pop();
}
result=qu1.front();
qu1.pop();
qu2.push(result);
}
return result;
}
bool empty() {
if(qu1.empty()&&qu2.empty())
{
return true;
}
return false;
}
private:
queue qu1;
queue qu2;
};
/**
* 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();
* bool param_4 = obj->empty();
*/