一、括号匹配问题
使用C语言要自己定义好栈，在bool isValid 之前的都是栈的基本接口的定义和实现；
typedef char DataType;
//栈
typedef struct Stack
{
DataType* data;
int top;
int capacity;
}Stack;
//栈的初始化
void StackInit(Stack* pst);
//栈的销毁
void StackDestroy(Stack* pst);
//栈入数据
void StackPush(Stack* pst, DataType x);
//栈出数据
void StackPop(Stack* pst);
//栈的判空
bool StackEmpty(Stack* pst);
//返回栈顶数据
DataType StackTop(Stack* pst);
//栈中的元素个数
int StackSize(Stack* pst);
//栈的初始化
void StackInit(Stack* pst)
{
assert(pst);
pst->data = NULL;
pst->capacity = pst->top = 0;
}
//栈的销毁
void StackDestroy(Stack* pst)
{
assert(pst);
if (pst->data != NULL)//free不能释放NULL
{
free(pst->data);
}
pst->data = NULL;
pst->capacity = pst->top = 0;
}
//栈入数据
void StackPush(Stack* pst, DataType x)
{
assert(pst);
int newcapacity = pst->capacity == 0 ? 4 : 2 * pst->capacity;
if (pst->capacity == pst->top)//空间不够，申请空间
{
DataType* tmp = (DataType*)realloc(pst->data, sizeof(DataType) * newcapacity);
if (tmp == NULL)
{
perror("malloc fail");
return;
}
pst->data = tmp;//realloc自动释放掉旧的空间
pst->capacity = newcapacity;
}
pst->data[pst->top++] = x;
}
//栈出数据
void StackPop(Stack* pst)
{
assert(pst);
pst->top--;
}
//栈的判空
bool StackEmpty(Stack* pst)
{
assert(pst);
return pst->top == 0 ? true : false;
}
//返回栈顶数据
DataType StackTop(Stack* pst)
{
assert(pst);
return pst->data[pst->top - 1];
}
//栈中元素个数
int StackSize(Stack* pst)
{
assert(pst);
return pst->top;
}
bool isValid(char* s) {
Stack st;
StackInit(&st);
while(*s)
{
if(*s=='('||*s=='['||*s=='{')//左括号入栈
{
StackPush(&st,*s);
}
else//右括号出栈
{
if(StackEmpty(&st))
{
StackDestroy(&st);
return false;
}
else
{
char top=StackTop(&st);
StackPop(&st);
if(top=='['&&*s!=']' ||
top=='{'&&*s!='}' ||
top=='('&&*s!=')' )
{
StackDestroy(&st);
return false;
}
}
}
s++;
}
if(!StackEmpty(&st))
{
StackDestroy(&st);
return false;
}
return true;
}###本题思路：
首先括号一定要左右两两对应；使用栈：遍历s字符串的时，若是左括号就入栈，若是右括号就出栈里面的一个左括号，再看这个左括号和右括号匹配与否；
使用栈的好处就是能够每次碰到右括号的时候都拿出栈顶数据（一定是左括号）来判断；
###代码解读：
首先定义并初始化一个栈，开始遍历字符串，字符串为 '\0' 时，跳出循环，此时字符串里面括号判断完成了；首先是左括号入栈，第二轮循环若是左括号再入栈，后面同样如此，只到遍历到一个右括号的时候，拿出栈里面的一个左括号来和这个右括号进行匹配（这对左、右括号一定是要进行判断的一对），匹配失败就返回false，匹配成功继续遍历字符串；之后操作雷同；
注意：循环中右括号匹配的分支语句中的if判断是栈为空，也就是还没有左括号进栈，因为判断是否是左括号并且再入栈的语句在前面，若是栈为空，那么说明字符串里面的第一个括号是右括号，那么就直接返回false，这时因为在这个右括号的左边没有括号来匹配；
出了循环，可能还剩下多余的括号，剩下多余的括号一定都是左括号（只有左括号才入栈，若是s字符串里面右括号多，那么在循环里面就返回false了，若是左括号多，右括号都匹配完，但是多余的左括号不会再循环里面使得函数结束），此时说明字符串里面有不能配对的左括号，那么就返回false
返回路径前面都加上栈的销毁，若是直接返回，那么在堆上开辟的空间还需要在函数之外free。
二、用两个队列实现栈
MyStack* myStackCreate()之前都是队列的基本操作定义；
typedef struct QueueNode
{
int val;
struct QueueNode* next;
}QNode;
typedef struct Queue
{
QNode* head;
QNode* tail;
int size;
}Queue;
//初始化队列
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = NULL;
pq->tail = NULL;
pq->size = 0;
}
//数据入队列
void QueuePush(Queue* pq, int x)//单链表尾插
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(1);
}
newnode->next = NULL;
newnode->val = x;
if (pq->tail == NULL)
{
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
pq->size++;
}
//数据出队列
void QueuePop(Queue* pq)//单链表头删
{
assert(pq);
assert(pq->size);
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;
}
pq->size--;
}
//获取队尾元素
int QueueBack(Queue* pq)
{
assert(pq && pq->size);
return pq->tail->val;
}
//获取队头元素
int QueueFront(Queue* pq)
{
assert(pq && pq->size);
return pq->head->val;
}
//队列判空
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->size == 0 ? true : false;
}
//队列的大小
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
//销毁队列
void QueueDestroy(Queue* pq)
{
assert(pq);
QNode* cur=pq->head;
while(cur)
{
QNode* next=cur->next;
free(cur);
cur=next;
}
pq->head=pq->tail=NULL;
pq->size=0;
}
typedef struct {
Queue q1;
Queue q2;
} MyStack;
MyStack* myStackCreate() {
MyStack* mst=(MyStack*)malloc(sizeof(MyStack));
QueueInit(&mst->q1);
QueueInit(&mst->q2);
return mst;
}
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))
{
nonempty=&obj->q1;
empty=&obj->q2;
}
while(QueueSize(nonempty)>1)
{
int pop=QueueFront(nonempty);
QueuePop(nonempty);
QueuePush(empty,pop);
}//把size-1前个元素导入为空的队列，并且一边导入一边删除不为空的队列的数据，当
//只剩不为空的队列只剩下最后一个元素的时候，停止导入，返回并删除掉这个元素
int tmp=QueueFront(nonempty);
QueuePop(nonempty);
return tmp;
}
int myStackTop(MyStack* obj) {
return QueueEmpty(&obj->q1)==true?QueueBack(&obj->q2):QueueBack(&obj->q1);
}
bool myStackEmpty(MyStack* obj) {
return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}
void myStackFree(MyStack* obj)
{
QueueDestroy(&(obj->q1));
QueueDestroy(&(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);
*/###本题思路：
用两个队列实现栈，队列是先进先出，而栈是后进先出；利用这个特点，往不为空的队列入数据，假设是1、2、3、4，那么出数据的顺序应该是4、3、2、1；为了实现这个过程，将存有数据的队列里面的数据1、2、3倒入没有数据的队列里面，那么这个没有数据的队列里面就存有数据了且从头到尾依次是1、2、3，此时再将只存有4的队列进行队列出数据的操作，并且保证了在每次删除数据结束之后都有一个队列中没有数据；
之后，这两个队列交换角色，再进行这样的操作；
三、用两个栈实现队列
MyQueue* myQueueCreate() 之前是栈的实现
typedef int DataType;
//栈
typedef struct Stack
{
DataType* data;
int top;
int capacity;
}Stack;
//栈的初始化
void StackInit(Stack* pst);
//栈的销毁
void StackDestroy(Stack* pst);
//栈入数据
void StackPush(Stack* pst, DataType x);
//栈出数据
void StackPop(Stack* pst);
//栈的判空
bool StackEmpty(Stack* pst);
//返回栈顶数据
DataType StackTop(Stack* pst);
//栈中的元素个数
int StackSize(Stack* pst);
//栈的初始化
void StackInit(Stack* pst)
{
assert(pst);
pst->data = NULL;
pst->capacity = pst->top = 0;
}
//栈的销毁
void StackDestroy(Stack* pst)
{
assert(pst);
if (pst->data != NULL)//free不能freeNULL
{
free(pst->data);
}
pst->data = NULL;
pst->capacity = pst->top = 0;
}
//栈入数据
void StackPush(Stack* pst, DataType x)
{
assert(pst);
int newcapacity = pst->capacity == 0 ? 4 : 2 * pst->capacity;
if (pst->capacity == pst->top)//空间不够，申请空间
{
DataType* tmp = (DataType*)realloc(pst->data, sizeof(DataType) * newcapacity);
if (tmp == NULL)
{
perror("malloc fail");
return;
}
pst->data = tmp;//realloc自动释放掉旧的空间
pst->capacity = newcapacity;
}
pst->data[pst->top++] = x;
}
//栈出数据
void StackPop(Stack* pst)
{
assert(pst);
pst->top--;
}
//栈的判空
bool StackEmpty(Stack* pst)
{
assert(pst);
return pst->top == 0 ? true : false;
}
//返回栈顶数据
DataType StackTop(Stack* pst)
{
assert(pst);
assert(pst->top >0);
int tmp=pst->top-1;
return pst->data[tmp];
}
//栈中元素个数
int StackSize(Stack* pst)
{
assert(pst);
return pst->top;
}
typedef struct {
Stack pushst;//存储数据的
Stack 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))
{
while(StackSize(&obj->pushst))
{
int top=StackTop(&obj->pushst);
StackPop(&obj->pushst);
StackPush(&obj->popst,top);
}
}
int front=StackTop(&obj->popst);
StackPop(&obj->popst);
return front;
}
int myQueuePeek(MyQueue* obj) {
if(StackEmpty(&obj->popst))
{
while(StackSize(&obj->pushst))
{
int top=StackTop(&obj->pushst);
StackPop(&obj->pushst);
StackPush(&obj->popst,top);
}
}
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);
}
/**
* 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);
*/###本题思路：
两个栈实现队列，栈是后进先出，队列是先进先出，定义好两个栈，pushst（专门进数据的栈）、popst（专门出数据得到栈），每次对列入数据的时候就往pushst里面入数据，队列出数据的把pushst里面的数据全部倒入popst里面，（因为栈是后进先出，所以当pushst入数据顺次依次是1、2、3、4的时候，倒入popst里面就是4、3、2、1）此时再出数据，出数据顺序就是1、2、3、4（popst删除栈顶的数据）那么就和一个队列的出入数据方式相同了；
当popst里面还有数据时，可以不往popst里面倒入数据，只到popst里面的数据出完，再把pushst里面的数据倒入popst里面；这种方式并不影响队列的实现。
四、设计循环队列
循环队列是一个线性表。它的特殊之处在于可以用有限的空间一直存储值，当然数据超过空间大小的时候，新进来的数据会覆盖掉之前的数据，但是这种结构可以不停的存储；
方法一：多开辟一个空间
typedef struct {
int* a;
int head;
int tail;
int k;
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
obj->a=(int*)malloc(sizeof(int)*(k+1));
obj->head=0;
obj->tail=0;
obj->k=k;
return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->tail==obj->head;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return (obj->tail+1)%(obj->k+1)==obj->head;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if(myCircularQueueIsFull(obj))
return false;
obj->a[obj->tail++] = value;
(obj->tail) %= (obj->k+1);
return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return false;
obj->head++;
obj->head %= (obj->k+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;
int top=0;
if(obj->tail==0)
{
top=obj->k;
}
else
{
top=obj->tail-1;
}
return obj->a[top];
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->a);obj->a=NULL;
obj->head = obj->tail = obj->k = 0;
free(obj); obj=NULL;
}
/**
* Your MyCircularQueue struct will be instantiated and called as such:
* MyCircularQueue* obj = myCircularQueueCreate(k);
* bool param_1 = myCircularQueueEnQueue(obj, value);
* bool param_2 = myCircularQueueDeQueue(obj);
* int param_3 = myCircularQueueFront(obj);
* int param_4 = myCircularQueueRear(obj);
* bool param_5 = myCircularQueueIsEmpty(obj);
* bool param_6 = myCircularQueueIsFull(obj);
* myCircularQueueFree(obj);
*/假设原本要实现的队列长度是4，那么就开辟5个数据大小的空间，让tail指向队尾数据的下一个，让head指向对头数据；
入数据时，让tail位置赋值为此数据，tail++，但是每次入完，就要让tail取模，保证tail是比k小的
出数据时head++，让前面的数据不在队列里面。队列是从头（head）开始的，出完数据之后，再让head取模操作，保证head小于k
判空的时候：head==tail即为空；判满：tial的下一个为head时，但是当tail在k处的时候下一个是k+1，而head不可能在此处，所以利用 (obj->tail+1)%(obj->k+1)==obj->head 来判断tail的下一个是不是tail，这样避免此问题；
返回队头数据，就是head处的数据，而返回队尾数据的时候，tail处的位置不存放数据，只有其前面一个才是队尾数据，此时不能返回tail-1位置的数据，因为当tail是0时那么下标就成了-1，出错，所以加上一个if语句，当tail为0时，返回k处的数据；
多开辟一个空间的好处：
避免了假溢出的问题；假溢出就是实际空间未满，但是计算机因为你写的程序不当，认为这个空间已经满了；在这里的体现就是，判空判满的时候，若是没有多开辟一个空间，那么队列为空为满的情况head都等于tail，此时明明未满但还是可能被认作满了。
方法二：定义一个size记录队列里面元素的个数
typedef struct {
int* a;
int head;
int tail;
int k;//后续会用到队列长度
int size;
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
obj->a = (int*)malloc(sizeof(int) * k);
obj->head = 0;
obj->tail = 0;
obj->k = k;
obj->size = 0;
return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->size == 0;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return obj->size == obj->k;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if (myCircularQueueIsFull(obj))
{
return false;
}
//走到这里说明还没有满,size小于4
obj->a[obj->tail++] = value;
obj->size++;
obj->tail %= obj->k;
return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj))
{
return false;
}
obj->head++;
obj->size--;
obj->head %= obj->k;
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->tail == 0 ? obj->a[obj->k - 1] : obj->a[obj->tail - 1];
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->a); obj->a = NULL;
obj->head = obj->tail = obj->k = obj->size = 0;
free(obj);
obj = NULL;
}
/**
* Your MyCircularQueue struct will be instantiated and called as such:
* MyCircularQueue* obj = myCircularQueueCreate(k);
* bool param_1 = myCircularQueueEnQueue(obj, value);
* bool param_2 = myCircularQueueDeQueue(obj);
* int param_3 = myCircularQueueFront(obj);
* int param_4 = myCircularQueueRear(obj);
* bool param_5 = myCircularQueueIsEmpty(obj);
* bool param_6 = myCircularQueueIsFull(obj);
* myCircularQueueFree(obj);
*/此处为开辟多的空间，为了避免假溢出的问题定义一个size记录队列里面元素的个数，当size==k的时候就说明满了，当size==0的时候说明为空；
取模思路雷同方法一，都是当head或是tail超过了合法下标范围时，膜上k更新head或者是tail的值；
队列有效的数据只在head和tail之间，那些其他数据虽然没有处理，但是不影响函数的调用
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
