【C】浅刷栈和队列OJ题
上一篇文章我们使用C语言实现了栈和队列，本章我们利用栈和队列的结构性质讲解几道相关的OJ题，更深刻地理解栈和队列。
目录
1、括号匹配问题
2、用队列实现栈
3、用栈实现队列
4、设计循环队列
1、括号匹配问题
力扣
https://leetcode.cn/problems/valid-parentheses/
对于这道题目的思考，我们试想历遍数组数左右括号个数，但是括号有顺序匹配的问题，左右指针双向历遍也不乏实例2这样带给我们的困惑。联想我们刚刚讲解过的栈，大家会不会有一点思路呢？
这里我们给出一种思路。创建一个栈后，我们历遍s，如果是左半部分括号（也就是‘（’，‘ [ ’,' { '）则压栈，如果遇到右半部分括号，那么和栈顶的匹配，如果匹配上，则栈顶弹出一个元素，如果不匹配，那么返回FALSE，以此类推，直到历遍完s还没返回false则返回TRUE。
由于是C语言的OJ题，我们没有栈的库函数，栈的基本操作我们需要复制到代码段中（上篇文章有实现栈），这里我们再给出一部分栈实现的函数：
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* ps)
{
ps->a = NULL;
ps->top = 0;
ps->capacity = 0;
}
void StackDestory(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 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 = 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++;
}
bool StackEmpty(ST* ps)
{
assert(ps);
/*if (ps->top == 0)
{
return true;
}
else
{
return false;
}*/
return ps->top == 0;
}
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];
}
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
有了这些函数，我们下面就可以调用了，然后实现这道题目：
bool isValid(char * s){
ST st;
StackInit(&st);//初始化
while(*s)
{
if(*s=='{'||*s=='('||*s=='[')
{
StackPush(&st,*s);
s++;
}//左括号压栈
else
{
if(StackEmpty(&st))
{
StackDestory(&st);
return false;
}
STDataType top=StackTop(&st);
StackPop(&st);
if((*s=='}'&&top!='{')||
(*s==')'&&top!='(')||
(*s==']'&&top!='['))
{
StackDestory(&st);
return false;
}
else
{
++s;
}//右括号匹配
}
}
bool ret=StackEmpty(&st);//判断匹配完栈中是否为NULL。如果不为NULL，那么返回假
StackDestory(&st);
return ret;
}2、用队列实现栈
力扣https://leetcode.cn/problems/implement-stack-using-queues/
这道题目还是比较有意思的，用两个队列实现栈。
我们这道题从画图中寻找思路：
1、Push操作我们只需要把元素放入不为空的队列即可。
2、Top操作我们返回队尾的元素即可。
3、队列是先进先出的，上图所示，1先进队列那么1肯定先出队列，但是这时我们想到还有一个空队列，我们让上面的队列依次出队，然后入第二个队列直到上面的队列中只剩下最后一个元素，也就是队尾的元素，这时候让他出队我们就实现了模拟出栈的操作，这样就完成了pop的操作。
4、看两个队列是否都为空，我们就可以判断栈是否为空了，这样就实现了Empty操作。
我们先给出队列实现的一些分装函数：
typedef int QDataType;
typedef struct QueueNode
{
QDataType data;
struct QueueNode* next;
}QNode;
//记录头指针和尾指针
typedef struct Queue
{
QNode* head;
QNode* tail;
}Queue;
//队列的初始化
void QueueInit(Queue* pq);
//队列的销毁
void QueueDestroy(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);
//队列的初始化
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
}
//队列的销毁
void QueueDestroy(Queue* 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));
if (newnode == NULL)
{
//printf("%s\n", strerror(errno));
exit(-1);
}
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);
//头删 - 只有一种个结点的情况时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;
}
//队列中数据的个数
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;
}有了上述这些队列的函数，我们就可以按照上面画图得出的思想来实现栈了：
typedef struct
{
Queue q1;
Queue q2;
} MyStack;
MyStack* myStackCreate()
{
MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
if(pst == NULL)
exit(-1);
QueueInit(&pst->q1);
QueueInit(&pst->q2);
return pst;
}
void myStackPush(MyStack* obj, int x)
{
assert(obj);
if(!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1, x);
}
else
{
QueuePush(&obj->q2, x);
}
}
int myStackPop(MyStack* obj)
{
assert(obj);
Queue* empty = &obj->q1;
Queue* nonEmpty = &obj->q2;//先假设q1位空，然后判断，找出为空的队列
if(!QueueEmpty(empty))
{
empty = &obj->q2;
nonEmpty = &obj->q1;
}
while(QueueSize(nonEmpty) > 1)
{
QueuePush(empty,QueueFront(nonEmpty));
QueuePop(nonEmpty);
}
int top = QueueBack(nonEmpty);//把除最后一个元素的其他元素移到另一个队列，然后删除最后一个元素
QueuePop(nonEmpty);
return top;
}
int myStackTop(MyStack* obj)
{
assert(obj);
if(!QueueEmpty(&obj->q1))
{
return QueueBack(&obj->q1);
}
else
{
return QueueBack(&obj->q2);//不为空的队列的队尾元素即为栈顶
}
}
bool myStackEmpty(MyStack* obj)
{
assert(obj);
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
void myStackFree(MyStack* obj)
{
assert(obj);
QueueDestroy(&obj->q1);
QueueDestroy(&obj->q2);
free(obj);
}3、用栈实现队列
力扣https://leetcode.cn/problems/implement-queue-using-stacks/
延续上面的思想，我们画图找灵感：
建立两个栈，一个是PushST,另一个是PopST，顾名思义，一个是压入数据，一个是出数据的。
1、push操作是元素x移到队尾，我们直接把它压入PushST中。
2、pop是移除队头的数据，上图中我们先进的元素是1，所以要pop1，那么我们依次从PushST中拿出元素然后压入PopST中，那么得到如下图所示的PopST的栈，这时候我们把栈顶的元素移除掉即可
3、peek是返回队头的元素，也就是返回1，那么和操作2一样，我们只要取出PopST栈顶元素即可。
4、判断队列是否为空，我们只需要判断PushST和PopST是否同时为空即可。
栈的操作实现函数：
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* ps);
void StackDestory(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);
int StackSize(ST* ps);
bool StackEmpty(ST* ps);
void StackInit(ST* ps)
{
ps->a = NULL;
ps->top = 0;
ps->capacity = 0;
}
void StackDestory(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 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 = 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];
}
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
bool StackEmpty(ST* ps)
{
assert(ps);
/*if (ps->top == 0)
{
return true;
}
else
{
return false;
}*/
return ps->top == 0;
}按照上面操作，用栈实现队列的操作：
typedef struct {
ST pushST;
ST popST;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue* q=(MyQueue*)malloc(sizeof(MyQueue));
StackInit(&q->pushST);
StackInit(&q->popST);
return q;
}
void myQueuePush(MyQueue* obj, int x) {
StackPush(&obj->pushST,x);//直接让元素压栈到PushST中
}
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) {
StackDestory(&obj->pushST);
StackDestory(&obj->popST);
free(obj);
}4、设计循环队列
力扣https://leetcode.cn/problems/design-circular-queue/
这道题的描述有点长，仔细读完之后发现我们需要设计一个循环队列来实现一系列操作，我们给出下面的一种图描述：
大概可以理解成这样，前面删除的空间，我们后续入队时还可以利用，但实际上存储空间可不是环形的，我们再画出数组的图描述:
然后我们1,2,3,4入队，然后1,2出队，然后让5，6入队，我们可以画出下面的图：
有人就发现了，这里我们多给了一块空间，也就是上面Tail所在的位置，这是为什么呢？
假如我们不多开辟这一块空间，我们判空和判满的条件都是Tail和Front相等的，无法区别。额外开辟一块空间则可以让判空的条件是Front和Tail相等，判满条件则是Tail加1等于Front。
这道题目用顺序表实现很简单，最主要的就是循环我们要用到取模的操作，即%。
详细操作我们在代码中讲解。
typedef struct {
int* a;
int front;
int tail;
int k;//元素个数
} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);//判空和判满函数，取函数名放在头，以便调用，实现操作在下面
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue*cp=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));//开辟结构体空间
cp->a=(int*)malloc(sizeof(int)*(k+1));//开辟数组空间，多开辟一块额外的
cp->front=cp->tail=0;
cp->k=k;
return cp;
}
//插入一个元素
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if(myCircularQueueIsFull(obj))
return false;
else
{
obj->a[obj->tail]=value;//tail处插入，即为队尾插入
++obj->tail;
obj->tail%=(obj->k+1);//实现循环操作
return true;
}
}
//出队即为头删
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return false;
else
{
++obj->front;
obj->front%=(obj->k+1);//实现循环操作
return true;
}
}
//返回头元素
int myCircularQueueFront(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return -1;
else
return obj->a[obj->front];
}
//返回尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return -1;
else
{if(obj->tail==0)
return obj->a[obj->k];//特殊情况单独说明
else
return obj->a[obj->tail-1];
}
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
if(obj->front==obj->tail)
return true;
else
return false;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
if((obj->tail+1)%(obj->k+1)==obj->front)
return true;
else
return false;
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->a);
free(obj);
}