目录
前情回顾：
前言：
题目一：《有效括号》
思路：
总结：
题目二：《用队列实现栈》
思路：
总结：
题目三：《用栈实现队列》
思路：
总结 ：
总结：
前情回顾：
我们在上一篇好题分析中，分析了以下几题：
《反转链表》《相交链表》《环形链表（一）》《环形链表（二）》《随机链表的复制》《合并两个有序链表》
《链表中倒数第K个节点》《链表分割》《链表的回文结构》
上一篇的好题分析的blog:
好题分享（2023.11.5——2023.11.11）-CSDN博客
前言：
本次《好题分享》当中，我们主要熟悉我们刚刚所学的《栈和队列》这一部分内容。
通过三道Leecode题目使我们对于《栈和队列》能有一个更好的认识。
以下是我们需要解决的三道题目：
《有效括号》《用队列实现栈》《用栈实现队列》
这三道题的代码量都会非常的长，那是由于我们现在处于初学阶段，没有办法使用一些高效的方法来解决这些题目，但是不用怕，因为我们不仅仅实现过《栈》也实现过《队列》。
对于《栈和队列》的讲解可以去访问我的上一篇blog
《栈和队列》的模拟实现(顺序栈) (链队列)-CSDN博客
里面有需要实现本次题目的代码，打开我的Gitee即可获取。
在做题目之前我们首先需要将我们实现好的《栈》或者《队列》的代码粘贴到题目最前面的位置。
那么现在我们就来动手实践以及讲解
题目一：《有效括号》
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
typedef char STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void STInit(ST* pst)
{
pst->a = NULL;
pst->capacity = 0;
pst->top = -1;
}
void STDestory(ST* pst)
{
assert(pst);
free(pst);
pst = NULL;
}
void STPush(ST* pst, STDataType x)
{
assert(pst);
if (pst->capacity == pst->top || pst->top == -1)
{
int newCapacity = (pst->capacity == 0) ? 4 : 2 * (pst->capacity);
STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(ST)*newCapacity);
if (tmp == NULL)
{
perror("STPush -> realloc");
exit(-1);
}
pst->a = tmp;
pst->capacity = newCapacity;
}
pst->top++;
pst->a[pst->top] = x;
}
void STPop(ST* pst)
{
assert(pst);
pst->top--;
}
STDataType STTop(ST* pst)
{
assert(pst);
return pst->a[pst->top];
}
bool STEmpty(ST* pst)
{
assert(pst);
if (pst->top == -1)
{
return true;
}
return false;
}
int STSize(ST* pst)
{
assert(pst);
return (pst->top) + 1;
}
void STPrint(ST* pst)
{
assert(pst);
while (pst->top != -1)
{
printf("%d\n", STTop(pst));
STPop(pst);
}
}
bool isValid(char* s) {
ST st;
STInit(&st);
while(*s)
{
if(*s == '[' || *s == '(' || *s == '{')
{
STPush(&st,*s);
}
else
{
if(STEmpty(&st))
{
return false;
}
else
{
char top = STTop(&st);
STPop(&st);
if((top == '(' && *s != ')')
||(top == '{' && *s != '}')
|| (top == '[' && *s != ']'))
{
return false;
}
}
}
s++;
}
if(!STEmpty(&st))
{
return false;
}
return true;
}思路：
本题的思路就是利用《栈》的性质——先进后出
因为是匹配括号，我们不妨假设其本质就是一个《栈》。
我们先去遍历字符串，如果访问到左括号，例如
"{" "(" "["
就直接入栈。
而如果访问到右括号，我们就与栈顶的括号匹配，如果左右括号匹配成功就删除栈顶的括号，字符串继续遍历，直到遍历完成。
如图：
栈顶的括号与s指向的括号相匹配
此时相匹配，则删除栈顶元素：
如此继续遍历。
此时s指向'\0'代表遍历结束，而如果《栈》为空，就代表着字符串为有效括号，就可以return true
总结：
1.创建《栈》
2.遍历字符串，左括号入《栈》
3.遍历到右括号，则于《栈》顶的左括号相匹配
4.当字符串遍历完后，《栈》为空则return true;
但是这里存在一个细节，需要去注意
例如，如果我们在遍历字符串时遍历到有括号时，可是《栈》中没有栈顶元素与之匹配，则直接返回false。
题目二：《用队列实现栈》
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
typedef int QDataType;
typedef struct QueueNode
{
QDataType val;
struct QueueNode* next;
}QNode;
typedef struct Queue
{
QNode* phead;
QNode* ptail;
int sz;
}Queue;
void QueueInit(Queue* pq)
{
pq->sz = 0;
pq->phead = pq->ptail = NULL;
}
void QueueDestroy(Queue* pq)
{
assert(pq);
assert(pq->phead);
QNode* cur = pq->phead->next;
while (cur)
{
free(pq->phead);
pq->phead = cur;
cur = cur->next;
}
free(pq->phead);
pq->phead = pq->ptail = cur = NULL;
}
void QueuePop(Queue* pq)
{
assert(pq);
if (pq->phead == pq->ptail)
{
free(pq->phead);
pq->phead = pq->ptail = NULL;
}
else
{
QNode* tmp = pq->phead->next;
free(pq->phead);
pq->phead = tmp;
}
pq->sz--;
}
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("QueuePush -> malloc");
exit(-1);
}
newnode->val = x;
newnode->next = NULL;
if (pq->ptail == NULL)
{
pq->phead = pq->ptail = newnode;
}
else
{
pq->ptail->next = newnode;
pq->ptail = newnode;
}
pq->sz++;
}
QDataType QueueFront(Queue* pq)
{
assert(pq);
return pq->phead->val;
}
QDataType QueueBack(Queue* pq)
{
assert(pq);
return pq->ptail->val;
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
if (pq->phead == NULL)
{
return true;
}
return false;
}
int QueueSize(Queue* pq)
{
return pq->sz;
}
void QueuePrint(Queue* pq)
{
assert(pq);
QNode* cur = pq->phead;
while (cur)
{
printf("%d->", cur->val);
cur = cur->next;
}
printf("NULL\n");
}
typedef struct {
Queue q1;
Queue q2;
} MyStack;
MyStack* myStackCreate() {
MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
QueueInit(&pst->q1);
QueueInit(&pst->q2);
return pst;
}
void myStackPush(MyStack* obj, int x) {
if (QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2))
{
QueuePush(&obj->q1, x);
}
else
{
if (!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1, x);
}
else
{
QueuePush(&obj->q2, x);
}
}
}
int myStackPop(MyStack* obj) {
if (QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2))
{
return 0;
}
else
{
if (!QueueEmpty(&obj->q1))
{
int n = QueueSize(&obj->q1) - 1;
while (n)
{
int top = QueueFront(&obj->q1);
QueuePush(&obj->q2, top);
QueuePop(&obj->q1);
n--;
}
int top = QueueFront(&obj->q1);
QueuePop(&obj->q1);
return top;
}
else
{
int n = QueueSize(&obj->q2) - 1;
while (n)
{
int top = QueueFront(&obj->q2);
QueuePush(&obj->q1, top);
QueuePop(&obj->q2);
n--;
}
int top = QueueFront(&obj->q2);
QueuePop(&obj->q2);
return top;
}
}
}
int myStackTop(MyStack* obj) {
if (QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2))
{
return 0;
}
else
{
if (!QueueEmpty(&obj->q1))
{
return QueueBack(&obj->q1);
}
else
{
return QueueBack(&obj->q2);
}
}
}
bool myStackEmpty(MyStack* obj) {
if (!QueueEmpty(&obj->q1) || !QueueEmpty(&obj->q2))
{
return false;
}
return true;
}
void myStackFree(MyStack* obj) {
if (!QueueEmpty(&obj->q1) && !QueueEmpty(&obj->q2))
{
if (!QueueEmpty(&obj->q1))
{
QueueDestroy(&obj->q1);
}
else
{
QueueDestroy(&obj->q2);
}
}
}
/**
* 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);
*/该题目的代码量会非常长，刚开始做题时是会产生恐惧，但是不用害怕，因只要我们了解了其中代码的秘密，我们就能迎刃而解了。
思路：
由题意，就是让我们创建两个栈，然后通过两个栈之间的操作，完成一个队列的基本实现。
我们想要插入12345，那么对于栈来说
1就是《栈》底元素，5就是《栈》顶元素。
出栈也只能出5
但是对于队列而言呢？
队头是1，队尾是5
出队列也只能出1.
所以对于“出栈”就可以利用两个队列：
先让12345插入到队列1,即q1
再让q1中的各个元素一个个的进到队列q2中
如此不断循环
直到q1只剩一个元素，那个元素就是对应的“栈顶”。
我们将这个元素删除即可：
最后则返回top：
以上就是“出栈”的函数实现，那么对于入栈来说，就是哪个队列不为空就插入到哪个队列中。
具体的代码还是好实现的。后续的函数我也不做过多的赘述。
总结：
对于这道题我们讲解关于“出栈”函数的实现就可以解决大部分问题。
但是这道题的自定义数据类型可能会有人绕不清楚，接下来我画一张图大家就可以理解了：
我们在上一篇blog也讲过，创建一个结构体用来保存头指针和尾指针对象，可以大大提高传输效率，也可以使人理解透彻！
题目三：《用栈实现队列》
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void STInit(ST* pst)
{
assert(pst);
pst->a = NULL;
pst->capacity = 0;
pst->top = -1;
}
void STDestory(ST* pst)
{
assert(pst);
free(pst->a);
pst->a = NULL;
pst->top = -1;
pst->capacity = 0;
}
void STPush(ST* pst, STDataType x)
{
assert(pst);
int newcapacity = (pst->capacity == 0) ? 4 : 2 * (pst->capacity);
STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
if (tmp == NULL)
{
perror("STPush -> realloc");
exit(-1);
}
pst->a = tmp;
pst->capacity = newcapacity;
pst->top++;
pst->a[pst->top] = x;
}
void STPop(ST* pst)
{
assert(pst);
if (pst->top != -1)
{
pst->top--;
}
}
STDataType STTop(ST* pst)
{
assert(pst);
if (pst->top != -1)
{
return pst->a[pst->top];
}
return -1;
}
bool STEmpty(ST* pst)
{
assert(pst);
if (pst->top == -1)
{
return true;
}
return false;
}
int STSize(ST* pst)
{
assert(pst);
return pst->top + 1;
}
void STPrint(ST* pst)
{
assert(pst);
for (int i = 0; i <= pst->top; i++)
{
printf("%d ", pst->a[i]);
}
}
typedef struct {
ST SPush;
ST SPop;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
STInit(&obj->SPush);
STInit(&obj->SPop);
return obj;
}
void myQueuePush(MyQueue* obj, int x) {
STPush(&obj->SPush,x);
}
int myQueuePop(MyQueue* obj) {
int front = myQueuePeek(obj);
STPop(&obj->SPop);
return front;
}
int myQueuePeek(MyQueue* obj) {
if(STEmpty(&obj->SPop))
{
while(!STEmpty(&obj->SPush))
{
STPush(&obj->SPop,STTop(&obj->SPush));
STPop(&obj->SPush);
}
}
return STTop(&obj->SPop);
}
bool myQueueEmpty(MyQueue* obj) {
if(STEmpty(&obj->SPush) && STEmpty(&obj->SPop))
{
return true;
}
return false;
}
void myQueueFree(MyQueue* obj) {
STDestory(&obj->SPop);
STDestory(&obj->SPush);
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);
*/本题的代码与上题一样，先将实现栈的函数粘贴到该题目中。
思路：
我们还是先来讲讲“出队列”这个思路。
“出队列”秉持一个原则，就是先进先出
而出缺是后进先出，所以我们不得不继续用到两个栈。
但是这里我们不同于上一道题，我们必须定义两个栈
即一个栈只能入数据，一个栈是用来出数据的。
比如我还是将12345入栈。
如果是队列的话，只能实现先进先出，即将1删除。
所以我们可以借鉴上题那样，先将SPush里面的所以元素移到SPop中 ：
这样一来，我们只需要删除SPop的栈顶元素即可。
如果我们想要继续输入数据，也不需要将SPop里面的数据再倒入SPush中，只需要再SPush里面继续添加新数据。
反正，只要SPop这个栈里有数据，就先删除栈顶的，而对于添加数据，只需要向SPush里面添加即可。
当删完SPop后如果还想删数据，则继续将SPush里面的数据倒入SPop即可。
总结 ：
当然还是会有人对数据类型不是很理解，我还是画个图给大家观看：
总结：
本文主要以巩固《栈和队列》为主，从此以后的好题分析，我们主要给大家讲解最关键思路，以及部分重难点函数的实现。
同学们下来可以自己动手尝试编写编写。
记住
“坐而言不如起而行！”
Aciton speak louder than words!
![微信小程序开发者工具] ? Enable IDE Service (y/N) ESC[27DESC[27C](https://img-blog.csdnimg.cn/26280f6cb591478382f86ba346a6c0c3.png)
