剖析栈和队列OJ题

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;//队列1
    Queue q2;//队列2
} MyStack;


MyStack* myStackCreate() {
    MyStack* pst=(MyStack*)malloc(sizeof(MyStack));//申请一个MyStack类型的栈
    assert(pst);
    QueueInit(&pst->q1);//初始化队列1
    QueueInit(&pst->q2);//初始化队列2
    return 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);//释放q1
    QueueDestroy(&obj->q2);//释放q2
    free(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);//初始化pushST
    stackInit(&obj->popST);//初始化popST
    return 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; //队列存储有效数据长度为k
    return 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);
}