1.括号匹配问题

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
1.左括号必须用相同类型的右括号闭合。
2.左括号必须以正确的顺序闭合。
3.每个右括号都有一个对应的相同类型的左括号。

链接：https://leetcode.cn/problems/valid-parentheses/

思路分析

本题使用栈来做是最合适不过的，因为栈明确指出后进先出，先进后出。因此我们可以做一下考虑：
1.遇到左括号" ( ", " [ ", " { "，入栈
2.遇到右括号" ) ", " ] ", " } "，出栈，跟左括号要匹配，不匹配就报错。

参考代码

#pragma once
#include 
#include 
#include 
#include 
//创建栈结构
typedef char 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);//取栈顶数据
int stackSize(ST* ps);//栈的有效元素个数
bool stackEmpty(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->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 = (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(ps->top > 0);ps->top--;
}//判断是否为空
bool stackEmpty(ST* ps)
{assert(ps);return ps->top == 0;
}//取栈顶数据
STDataType stackTop(ST* ps)
{assert(ps);assert(ps->top > 0);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)){return false;//说明前面根本没有坐括号，导致栈为空，直接返回false}char top=stackTop(&st);//获取栈顶元素stackPop(&st);//出栈顶元素，接下来进行匹配if((*s==')'&&top!='(')||(*s==']'&&top!='[')||(*s=='}'&&top!='{')){stackDestroy(&st);//销毁是为了防止内存泄漏return false;//如果不匹配，直接返回false}else{++s;//此时匹配，接着继续比较，直到遍历结束}}}//栈为空，说明所有左括号都匹配bool ret=stackEmpty(&st);stackDestroy(&st);//防止内存泄漏return ret;
}

2.用队列实现栈

请你仅使用两个队列实现一个后入先出（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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

链接：https://leetcode.cn/problems/implement-stack-using-queues/

思路分析

首先要了解栈和队列的结构：
1.栈：后进先出
2.队列：先进先出
要是用队列实现栈就必须做到以下两步：
1.入栈：push数据到不为空的数据
2.出栈：把不为空队列的前n-1个导入到空队列中，最后将剩下的那个pop删掉。
核心：让一个队列先存储数据，另外一个队列空着，要出栈时，空队列用来导入数据（间接实现栈）

参考代码

//创建队列结构
typedef int QDataType;
//创建队列结点
typedef struct QueueNode
{struct QueueNode* next;//记录下一个结点QDataType data;//存储数据
}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);//出队列
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);QNode* cur = pq->head;while (cur != NULL){QNode* next = cur->next;free(cur);cur = next;}pq->head = pq->tail = NULL;
}//判空
bool QueueEmpty(Queue* pq)
{assert(pq);return pq->head == NULL;
}//入队列
void QueuePush(Queue* pq, QDataType x)
{assert(pq);//创建一个新结点保存数据QNode* newnode = (QNode*)malloc(sizeof(QNode));//暴力检测newnode,因为malloc的都要检测assert(newnode);newnode->next = NULL;newnode->data = x;//如果一开始没有数据，为空的情况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和head均不能为空//特殊：当删到head=tail位置时，tail会变成野指针if (pq->head->next == NULL){free(pq->head);pq->head = pq->tail = NULL;}//一般情况else{//保存head的下一个结点QNode* next = pq->head->next;free(pq->head);pq->head = next;}
}//获取队头元素
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;
}//获取有效元素个数
int QueueSize(Queue* pq)
{assert(pq);int n = 0;QNode* cur = pq->head;while (cur){++n;cur = cur->next;}return n;
}
// *******************************************************************/typedef struct {Queue q1;//队列1Queue q2;//队列2
} MyStack;MyStack* myStackCreate() {MyStack* pst=(MyStack*)malloc(sizeof(MyStack));//申请一个MyStack类型的栈assert(pst);QueueInit(&pst->q1);//初始化队列1QueueInit(&pst->q2);//初始化队列2return pst;
}void myStackPush(MyStack* obj, int x) {assert(obj);if(!QueueEmpty(&obj->q1)){QueuePush(&obj->q1,x);//如果q1不为空，就往q1插入数据}else{QueuePush(&obj->q2,x);//这里直接push}
}int myStackPop(MyStack* obj) {assert(obj);Queue* emptyQ=&obj->q1;//默认q1为空Queue* nonEmtpyQ=&obj->q2;//默认q2不为空if(!QueueEmpty(&obj->q1)){emptyQ=&obj->q2;//若假设错误，则q2为空nonEmtpyQ=&obj->q1;//此时q1就为空       }while(QueueSize(nonEmtpyQ)>1){QueuePush(emptyQ,QueueFront(nonEmtpyQ));//把非空的导入空的队列，直到剩下最后一个QueuePop(nonEmtpyQ);//此时把非空的队头数据删掉，便于后面导入数据}int top=QueueFront(nonEmtpyQ);//记录此时的栈顶数据QueuePop(nonEmtpyQ);//删除栈顶数据，置空队列return top;
}int myStackTop(MyStack* obj) {assert(obj);if(!QueueEmpty(&obj->q1)){return QueueBack(&obj->q1);//如果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);//释放q1QueueDestroy(&obj->q2);//释放q2free(obj);
}

3.用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

链接：https://leetcode.cn/problems/implement-queue-using-stacks/

思路分析

题目让我们用两个栈来实现一个队列，就是要让两个栈实现一个先进先出的数据结构。
思路是：「输入栈」会把输入顺序颠倒；如果把「输入栈」的元素逐个弹出放到「输出栈」，再从「输出栈」弹出元素的时候，则可以负负得正，实现了先进先出。
具体做法：
可以把一个栈当做「输入栈」，把另一个栈当做「输出栈」。
当 push() 新元素的时候，放到「输入栈」的栈顶，记此顺序为「输入序」。
当 pop() 元素的时候，是从「输出栈」弹出元素。如果「输出栈」为空，则把「输入栈」的元素逐个 pop() 并且 push() 到「输出栈」中，这一步会把「输入栈」的栈底元素放到了「输出栈」的栈顶。此时负负得正，从「输出栈」的 pop() 元素的顺序与「输入序」相同。

参考代码

//创建栈的结构
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);//取栈顶数据
int stackSize(ST* ps);//栈的大小
bool stackEmpty(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->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 = (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(ps->top > 0);ps->top--;
}bool stackEmpty(ST* ps)
{assert(ps);return ps->top == 0;
}STDataType stackTop(ST* ps)
{assert(ps);assert(ps->top > 0);return ps->a[ps->top - 1];
}int stackSize(ST* ps)
{assert(ps);return ps->top;
}/******************************************************/typedef struct {ST pushST;//插入数据的栈ST popST;//删除数据的栈
} MyQueue;MyQueue* myQueueCreate() {MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));//申请队列类型assert(obj);stackInit(&obj->pushST);//初始化pushSTstackInit(&obj->popST);//初始化popSTreturn obj;
}void myQueuePush(MyQueue* obj, int x) {assert(obj);stackPush(&obj->pushST,x);//无论有没有数据，都要插入
}int myQueuePop(MyQueue* obj) {assert(obj);if(stackEmpty(&obj->popST))//如果popST数据为空，要从pushST里导入数据才能删除{while(!stackEmpty(&obj->pushST))//pushST数据不为空，就一直向popST里面导入数据{stackPush(&obj->popST,stackTop(&obj->pushST));//把pushST栈顶数据导入到popST里stackPop(&obj->pushST);//删除popST栈顶元素，实现队列先进先出}}int front=stackTop(&obj->popST);//记录popST栈顶元素stackPop(&obj->popST);//删除popST栈顶元素，实现队列先进先出return front;//返回栈顶数据
}int myQueuePeek(MyQueue* obj) {assert(obj);//如果popST数据为空，要从pushST里导入数据才能取到队头数据if(stackEmpty(&obj->popST)){while(!stackEmpty(&obj->pushST))//pushST数据不为空，就一直向popST里导入数据{stackPush(&obj->popST,stackTop(&obj->pushST));//把pushST栈顶数据导入到popST里stackPop(&obj->pushST);//导完后把pushST栈顶元素删掉，便于后面继续导}}return stackTop(&obj->popST);//直接返回栈顶元素
}bool myQueueEmpty(MyQueue* obj) {return stackEmpty(&obj->pushST)&&stackEmpty(&obj->popST);
}void myQueueFree(MyQueue* obj) {assert(obj);stackDestroy(&obj->pushST);stackDestroy(&obj->popST);free(obj);
}

4.设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
你的实现应该支持如下操作：
MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

链接：https://leetcode.cn/problems/design-circular-queue/

思路分析

参考代码

typedef struct {int* a; //用数组模拟环形队列int front;//队头int tail; //队尾int k; //表示存的数据长度为k
} MyCircularQueue;bool myCircularQueueIsFull(MyCircularQueue* obj); //前置声明
bool myCircularQueueIsEmpty(MyCircularQueue* obj);//前置声明MyCircularQueue* myCircularQueueCreate(int k) {MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));//创建环形链表结构assert(obj);obj->a = (int*)malloc(sizeof(int) * (k + 1));//多开一个空间，便于后续区分空或满obj->front = obj->tail = 0;obj->k = k; //队列存储有效数据长度为kreturn obj;
}bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {if (myCircularQueueIsFull(obj)){return false; //队列已满，不能插入数据}obj->a[obj->tail] = value; //赋值if (obj->tail == obj->k){obj->tail = 0; //当tail走到尾端}else{obj->tail++;}return true;
}bool myCircularQueueDeQueue(MyCircularQueue* obj) {if (myCircularQueueIsEmpty(obj)){return false; //队列为空，不能删除}if (obj->front == obj->k){obj->front = 0; //当front走到尾端}else{obj->front++;}return true;
}
//取头
int myCircularQueueFront(MyCircularQueue* obj) {if (myCircularQueueIsEmpty(obj)){return -1; //队列为空，取不了}return obj->a[obj->front]; //返回队头
}
//取尾
int myCircularQueueRear(MyCircularQueue* obj) {if (myCircularQueueIsEmpty(obj)){return -1; //队列为空，取不了}if (obj->tail == 0){return obj->a[obj->k]; //tail为0，队尾在长度的最后一个位置}else{return obj->a[obj->tail - 1];}
}bool myCircularQueueIsEmpty(MyCircularQueue* obj) {return obj->front == obj->tail; //front==tail时为空
}bool myCircularQueueIsFull(MyCircularQueue* obj) {if (obj->tail == obj->k && obj->front == 0){return true; //当tail尾端，front在头端时也是满}else{return obj->tail + 1 == obj->front; //一般情况，当tail的下一个位置为front时为满}
}void myCircularQueueFree(MyCircularQueue* obj) {free(obj->a);free(obj);
}