前言

在我们学习了栈和队列之后，今天来通过几道练习题来巩固一下我们的知识。

题目一 用栈实现队列

题目链接：232. 用栈实现队列 - 力扣（Leetcode）

这道题难度不是很大，重要的是我们对结构认识的考察，由于这篇文章我们是通过C语言解决的，所以我们必须先去构造一个栈，并且可以进行栈的各种操作，最终实现队列的实现。

typedef int datetype;typedef struct Stack
{datetype* a;int capacity;int top;
}stack;
//初始化
void stackInit(stack* p);
//销毁
void stackDestroy(stack* p);
//入栈
void stackPush(stack* p, datetype x);
//出栈
void stackPop(stack* p);
//取栈顶数据
datetype stackTop(stack* p);
//数据个数
int stackSize(stack* p);
//判断是否为空
bool stackEmpty(stack* p);
bool isValid(char* s);
void stackInit(stack* p)
{assert(p);p->a = NULL;p->capacity = 0;p->top = 0;
}
void stackPush(stack* p,datetype x)
{assert(p);if (p->capacity == p->top){int newCapacity = p->capacity == 0 ? 4 : 2 * p->capacity;datetype* tmp = (datetype*)realloc(p->a, newCapacity * sizeof(datetype));if (tmp == NULL){perror("realloc");exit(-1);}p->a = tmp;p->capacity=newCapacity;}p->a[p->top] = x;p->top++;
}void stackPop(stack* p)
{assert(p);assert(!stackEmpty(p));p->top--;
}void stackDestroy(stack* p)
{assert(p);if (p->capacity == 0)return;free(p->a);p->a = NULL;p->capacity = 0;p->top = 0;
}datetype stackTop(stack* p)
{assert(p);assert(!stackEmpty(p));return p->a[p->top-1];
}bool stackEmpty(stack* p)
{assert(p);return p->top==0;
}
int stackSize(stack* p)
{assert(p);return p->top;
}
//定义进行出数据和入数据的栈
typedef struct {stack pushST;stack popST;
} MyQueue;//创建队列，使用两个栈来实现
MyQueue* myQueueCreate() {MyQueue* tmp=(MyQueue*)malloc(sizeof(MyQueue));stackInit(&tmp->pushST);stackInit(&tmp->popST);return tmp;
}
//直接将数据入pushST
void myQueuePush(MyQueue* obj, int x) {stackPush(&obj->pushST,x);
}
//如过popST内不为空，直接输出数据，如果为空,将pushST数据都入到popST内
int myQueuePop(MyQueue* obj) {if(stackEmpty(&obj->popST)){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)){while(!stackEmpty(&obj->pushST)){stackPush(&obj->popST,stackTop(&obj->pushST));stackPop(&obj->pushST);}}return stackTop(&obj->popST);
}bool myQueueEmpty(MyQueue* obj) {return stackEmpty(&obj->pushST)&&stackEmpty(&obj->popST);
}void myQueueFree(MyQueue* obj) {stackDestroy(&obj->pushST);stackDestroy(&obj->popST);free(obj);obj=NULL;
}

这道题我们使用两个栈，一个栈负责出数据，一个栈负责入数据，当入数据时，直接push即可，当出数据时，我们使用两个栈配合，使用栈先入先出的特点，将pushST的内容入到popST时，数据就已经变成了逆序，所以在popST栈内，直接出就可以实现队列的先入后出的功能。

题目二 用队列实现栈

题目链接：225. 用队列实现栈 - 力扣（Leetcode）

这道题与上道题类似，都是对结构的考察，使用队列先入先出的特点，通过两个队列之前出数据入数据后，可以实现栈的功能，当一个队列出队进入另外一个队列，只剩一个数据时，直接将这个数据出队列，两个队列互相配合，最终将所有数出队，实现栈的功能。

typedef int QDataType;typedef struct QueueNode
{struct QueueNode* next;QDataType data;
}QueueNode;typedef struct Queue
{QueueNode* head;QueueNode* tail;// size_t _size;
}Queue;//void QueueInit(QueueNode** pphead, QueueNode** pptail);
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);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);void QueueInit(Queue* pq)
{assert(pq);pq->head = NULL;pq->tail = NULL;
}void QueueDestroy(Queue* pq)
{assert(pq);QueueNode* cur = pq->head;while (cur != NULL){QueueNode* next = cur->next;free(cur);cur = next;}pq->head = pq->tail = NULL;
}void QueuePush(Queue* pq, QDataType x)
{assert(pq);QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));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);//if (pq->head == NULL)//    return;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;
}int QueueSize(Queue* pq)
{assert(pq);int n = 0;QueueNode* cur = pq->head;while (cur){++n;cur = cur->next;}return n;
}bool QueueEmpty(Queue* pq)
{assert(pq);return pq->head == NULL;
}typedef struct {Queue q1;Queue q2;
} MyStack;MyStack* myStackCreate() {MyStack* ret =(MyStack*)malloc(sizeof(MyStack));QueueInit(&ret->q1);QueueInit(&ret->q2);return ret;
}//哪个队列不为空，就在哪个队列入数据
void myStackPush(MyStack* obj, int x) {if(!QueueEmpty(&obj->q1)){QueuePush(&obj->q1,x);}else{QueuePush(&obj->q2,x);}
}
//找到为空和不为空的队列，将不为空的队列出为只剩一个数据，直接出这个数据
int myStackPop(MyStack* obj) {Queue* empty = &obj->q1;Queue* nonempty = &obj->q2;if(!QueueEmpty(&obj->q1)){empty = &obj->q2;nonempty = &obj->q1;}while(QueueSize(nonempty)>1){QueuePush(empty,QueueFront(nonempty));QueuePop(nonempty);}int ret=QueueFront(nonempty);QueuePop(nonempty);return ret;
}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);
}

题目三 设计循环队列

题目链接：622. 设计循环队列 - 力扣（Leetcode）

我们之前实现队列是使用链表来实现的，当然也可以使用顺序表来实现，考虑到这道题循环队列的特殊结构，我们使用顺序表和链表两种方式来解决这个问题。

方法一：使用链表解决

首先定义每个结点的结构，再定义一个结构来存head，tail，数据个数size，最大容量capacity,当数据个数等于最大容量时，说明队列已满，当数据个数size为0时，说明队列为空。

typedef struct qNode
{int data;struct qNode* next;
}qNode;typedef struct {qNode* head;qNode* tail;int size;int capacity;
} MyCircularQueue;bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);MyCircularQueue* myCircularQueueCreate(int k) {MyCircularQueue* cq=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));cq->head=cq->tail=NULL;cq->capacity=k;cq->size=0;return cq;
}bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {if(myCircularQueueIsFull(obj)){return false;}qNode* newNode=(qNode*)malloc(sizeof(qNode));newNode->data=value;newNode->next=NULL;if(obj->size==0){obj->head=obj->tail=newNode;}else{obj->tail->next=newNode;obj->tail=newNode;}obj->size++;return true;
}bool myCircularQueueDeQueue(MyCircularQueue* obj) {if(myCircularQueueIsEmpty(obj)){return false;}qNode* next=obj->head->next;free(obj->head);obj->head=next;obj->size--;return true;
}int myCircularQueueFront(MyCircularQueue* obj) {if(myCircularQueueIsEmpty(obj))return -1;return obj->head->data;
}int myCircularQueueRear(MyCircularQueue* obj) {if(myCircularQueueIsEmpty(obj))return -1;return obj->tail->data;
}bool myCircularQueueIsEmpty(MyCircularQueue* obj) {return !obj->size;
}bool myCircularQueueIsFull(MyCircularQueue* obj) {return obj->size==obj->capacity;
}
void myCircularQueueFree(MyCircularQueue* obj) {if(myCircularQueueIsEmpty(obj)){free(obj);return;}qNode* cur=obj->head;while(cur!=obj->tail){qNode* next = cur->next;free(cur);cur = next;}free(obj);obj=NULL;
}

方法二：使用顺序表解决

使用顺序表，当head==tail时，说明队列为空，当head==tail+1时，说明队列为满。

typedef struct {int* a;int head;int tail;int capacity;
} MyCircularQueue;bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);MyCircularQueue* myCircularQueueCreate(int k) {MyCircularQueue* cq=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));cq->a = (int*)malloc(sizeof(int)*(k+1));cq->head=cq->tail=0;cq->capacity=k;return cq;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {return obj->head==obj->tail;
}bool myCircularQueueIsFull(MyCircularQueue* obj) {return (obj->tail+1)%(obj->capacity+1)==obj->head;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {if(myCircularQueueIsFull(obj)){return false;}obj->a[obj->tail++]=value;obj->tail = obj->tail % (obj->capacity+1);return true;
}bool myCircularQueueDeQueue(MyCircularQueue* obj) {if(myCircularQueueIsEmpty(obj)){return false;}obj->head++;obj->head=obj->head%(obj->capacity+1);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;return obj->a[obj->tail];
}
void myCircularQueueFree(MyCircularQueue* obj) {free(obj->a);free(obj);
}

总结

我们今天讲解了栈与队列的笔试题，希望可以得到大家的支持。