栈和队列面试题讲解(有效的括号、用队列实现栈、用栈实现队列、设计循环队列)

今天，我将带来栈和队列的面试题讲解。

- 有效的括号：[链接](https://leetcode.cn/problems/valid-parentheses/)
- 用队列实现栈：[链接](https://leetcode.cn/problems/implement-stack-using-queues/)
- 用栈实现队列：[链接](https://leetcode.cn/problems/implement-queue-using-stacks/)
- 设计循环队列：[链接](https://leetcode.cn/problems/design-circular-queue/)

有效的括号：链接

题目要求:给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

如上面的三个示例，我们需要判断括号是不是配对的。

思路1:使用栈来存储这些括号，理由:假如我们要验证"( [ ] )"里面的括号是否配对成功，那么我们将左括号( [ 存储进去栈，来到右括号 ] 时，就不要存储进去栈了，而是拿出栈顶的括号，即 [ 进行比对，利用了栈后进先出的道理

注意:在C语言中，我们只能自己去写一个栈，等到C++的时候，我们就可以直接使用库实现的栈了，所以C语言的代码实现相对较为麻烦。

代码:

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef char StackDataType;

typedef struct Stack
{
    StackDataType* data;
    int pos;
    int capacity;
}Stack;

void InitStack(Stack* ps)
{
    assert(ps);

    ps->data = (StackDataType*)malloc(sizeof(StackDataType) * 4);
    if(ps->data == NULL)
    {
        perror("InitStack()");
        exit(1);
    }
    ps->pos = 0;
    ps->capacity = 4;
}

bool StackEmpty(Stack* ps)
{
    assert(ps);

    return ps->pos == 0;
}

size_t StackSize(Stack* ps)
{
    assert(ps);

    return ps->pos;
}

void StackPush(Stack* ps,StackDataType x)
{
    assert(ps);

    if(ps->pos == ps->capacity)
    {
        StackDataType* tmp = (StackDataType*)realloc(ps->data,sizeof(StackDataType) * 2 * ps->capacity);
        if(tmp == NULL)
        {
            perror("StackPush()");
            exit(1);
        }
        ps->data = tmp;
        ps->capacity *= 2;    
    }
    ps->data[ps->pos++] = x;
}

void StackPop(Stack* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    ps->pos--;
}

StackDataType StackTop(Stack* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    return ps->data[ps->pos-1];
}

void DestroyStack(Stack* ps)
{
    free(ps->data);
    ps->data = NULL;
    ps->pos = 0;
    ps->capacity = 0;
}

bool isValid(char * s)
{
    Stack T;
    InitStack(&T);

    while(*s)
    {
        if(*s == '(' || *s == '{' || *s == '[')
        {
            StackPush(&T,*s);
            s++;
        }
        else
        {
            if(StackEmpty(&T))
            {
                DestroyStack(&T);
                return false;
            }
            else
            {
                char tmp = StackTop(&T);
                StackPop(&T);
                if(tmp != '{' && *s == '}' || 
                tmp != '(' && *s == ')' ||
                tmp != '[' && *s == ']')
                {
                    DestroyStack(&T);
                    return false;
                }
                else
                {
                    s++;
                }
            }    
        }
    }
    bool ret = StackEmpty(&T);
    DestroyStack(&T);
    return ret;
}

用队列实现栈：链接

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

代码:

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int QueueDataType;

typedef struct QueueNode
{
    QueueDataType data;
    struct QueueNode* next;
}QueueNode;

typedef struct Queue
{
    QueueNode* Head;
    QueueNode* Ptail;
    int size;
}Queue;

void InitQueue(Queue* ps)
{
    assert(ps);

    ps->Head = NULL;
    ps->Ptail = NULL;
    ps->size = 0;
}

void QueueDestroy(Queue* ps)
{
    assert(ps);

    QueueNode* cur = ps->Head;
    while(cur != NULL)
    {
        QueueNode* Next = cur->next;
        free(cur);
        cur = Next;
    }
    ps->Head = ps->Ptail = NULL;
    ps->size = 0;
}

bool QueueEmpty(Queue* ps)
{
    assert(ps);

    return ps->size == 0;
}

int QueueSize(Queue* ps)
{
    assert(ps);

    return ps->size;
}

void QueuePush(Queue* ps,QueueDataType x)
{
    assert(ps);

    QueueNode* NewNode = (QueueNode*)malloc(sizeof(QueueNode));
    if(NewNode == NULL)
    {
        perror("QueueNode()");
        exit(1);
    }
    NewNode->data = x;
    NewNode->next = NULL;
    if(ps->Ptail == NULL)
    {
        ps->Head = ps->Ptail = NewNode; 
    }
    else
    {
        ps->Ptail->next = NewNode;
        ps->Ptail = ps->Ptail->next;
    }            
    ps->size++;
}

void QueuePop(Queue* ps)
{
    assert(ps);
    assert(!QueueEmpty(ps));

    if(ps->Head->next == NULL)
    {
        free(ps->Head);
        ps->Head = ps->Ptail = NULL;
        ps->size = 0;
    }
    else
    {
        QueueNode* Next = ps->Head->next;
        free(ps->Head);
        ps->Head = Next;
        ps->size--;
    }
} 

QueueDataType QueueTop(Queue* ps)
{
    assert(ps);
    assert(!QueueEmpty(ps));

    return ps->Head->data;
}

QueueDataType QueueBack(Queue* ps)
{
    assert(ps);
    assert(!QueueEmpty(ps));

    return ps->Ptail->data;
}

typedef struct 
{
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() 
{
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    if(obj == NULL)
    {
        perror("myStackCreate()");
        exit(1);
    }
    InitQueue(&obj->q1);
    InitQueue(&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x) 
{
    assert(obj != NULL);

    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) 
{
    assert(obj != NULL);

    Queue* EmptyQ = &obj->q1;
    Queue* nonEmptyQ = &obj->q2;
    if(QueueEmpty(&obj->q1) != true)
    {
        EmptyQ = &obj->q2;
        nonEmptyQ = &obj->q1;
    }
    while(QueueSize(nonEmptyQ) > 1)
    {
        QueuePush(EmptyQ,QueueTop(nonEmptyQ));
        QueuePop(nonEmptyQ);
    }

    QueueDataType Top = QueueTop(nonEmptyQ);
    QueuePop(nonEmptyQ);
    return Top;
}

int myStackTop(MyStack* 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 != NULL);

    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

用栈实现队列：链接

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

代码:

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef int StackDataType;
typedef struct Stack
{
    StackDataType* data;
    int pos;
    int capacity;
}ST;

void InitStack(ST* ps)
{
    assert(ps);

    ps->data = (StackDataType*)malloc(sizeof(StackDataType) * 4); 
    if(ps->data == NULL)
    {
        perror("InitStack()");
        exit(1);
    }
    ps->pos = 0;
    ps->capacity = 4;
}

void StackPush(ST* ps,StackDataType x)
{
    assert(ps);

    if(ps->pos == ps->capacity)
    {
        StackDataType* tmp = realloc(ps->data,sizeof(StackDataType) * ps->capacity * 2);
        {
            if(tmp == NULL)
            {
                perror("StackPush()");
                exit(1);
            }
            ps->data = tmp;
            ps->capacity *= 2;
        }
    }
    ps->data[ps->pos] = x;
    ps->pos++;
}

bool StackEmpty(ST* ps)
{
    assert(ps);

    return ps->pos == 0;
}

int StackSize(ST* ps)
{
    assert(ps);

    return ps->pos;
}

void StackPop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    ps->pos--;
}

void StackDestroy(ST* ps)
{
    assert(ps);

    free(ps->data);
    ps->data = NULL;
    ps->capacity = 0;
    ps->pos = 0;
}

StackDataType StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    return ps->data[ps->pos-1];
}

typedef struct 
{
    ST PushST;
    ST PopST;
} MyQueue;


MyQueue* myQueueCreate() 
{
    MyQueue* tmp = (MyQueue*)malloc(sizeof(MyQueue));
    if(tmp == NULL)
    {
        perror("myQueueCreate()");
        exit(1);
    }
    InitStack(&tmp->PushST);
    InitStack(&tmp->PopST);
    return tmp;
}

void myQueuePush(MyQueue* obj, int x) 
{
    assert(obj);

    StackPush(&obj->PushST,x);
}

bool myQueueEmpty(MyQueue* obj) 
{
    assert(obj);

    return StackEmpty(&obj->PushST) && StackEmpty(&obj->PopST);
}

int myQueuePeek(MyQueue* obj) 
{
    assert(obj);
    assert(!myQueueEmpty(obj));

    if(StackEmpty(&obj->PopST))
    {
        while(!StackEmpty(&obj->PushST))
        {
            StackPush(&obj->PopST,StackTop(&obj->PushST));
            StackPop(&obj->PushST);
        }
    }

    return StackTop(&obj->PopST);
}

int myQueuePop(MyQueue* obj) 
{
    assert(obj);
    assert(!myQueueEmpty(obj));

    myQueuePeek(obj);
    int tmp = StackTop(&obj->PopST);
    StackPop(&obj->PopST);
    return tmp;
}

void myQueueFree(MyQueue* obj) 
{
    StackDestroy(&obj->PushST);
    StackDestroy(&obj->PopST);
    free(obj);
}

设计循环队列：链接

题目要求:设计你的循环队列实现。循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

思路:对于判断该循环队列是否已经满了的方法，我们可以采用定义一个变量size来统计循环队列的存储个数，通过这个存储个数来判断循环队列是否已经满了。
我们也可以采用多创建一个空结点，该结点不要存储数据，而是用来判断循环这个循环队列是否已经满了。

如上图是链表和数组实现的循环队列，当Front和Rear指向的空间相同时，该循环队列为空。

注意:链表实现的循环队列，Front和Rear是指针。数组实现的循环队列，Front和Rear是下标。

因为在开辟空间的时候，多开辟了一个空间的位置，但是不用来存储数据，所以两个循环链表的存储满的效果图如上。

对于链表实现的循环队列，判断条件是Rear->next == Front，该条件成立后，就可以确定该循环队列存储数据满了。

对于数组创建的循环队列，判断条件是（Rear+1）% （K+1）== Front（K为数据个数），该条件成立。就可以判断该循环队列存储数据满了。(注意数组的下标是从零开始的)

那么，我们现在就要在上面循环队列的两种实现方式挑选出最好的一种，相比数组实现的循环队列，链表实现的循环队列的最尾部数据是比较难找到的。数组实现的循环队列可以直接利用一条关于Rear的公式就可以找到，而链表实现的循环队列，却要定义一个指针从头结点遍历到后面，找到存储最后一个数据的地址。

总结:使用数组实现循环队列，并且通过多开辟一个数据的空间，间接来判断该数组实现的循环队列存储的数据空间是否已经满了。

代码:

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>

typedef int MCQDataType;
typedef struct 
{
    MCQDataType* data;
    int Front;
    int Rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->data = (MCQDataType*)malloc(sizeof(MCQDataType) * (k + 1));
    obj->Front = obj->Rear = 0;
    obj->k = k;

    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    assert(obj);

    return obj->Front == obj->Rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    assert(obj);

    return (obj->Rear + 1) % (obj->k + 1) == obj->Front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    assert(obj);

    if(myCircularQueueIsFull(obj))
        return false;
    obj->data[obj->Rear++] = value;
    //调整obj->Rear,使obj->Rear的值在0到k的范围内，如k等于5,obj->Rear的范围在0到5
    obj->Rear %= (obj->k+1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    assert(obj);

    if(myCircularQueueIsEmpty(obj))
        return false;   
    obj->Front++;
    //同上面的Rear
    obj->Front %= (obj->k+1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) 
{
    assert(obj);

    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->data[obj->Front];
}

int myCircularQueueRear(MyCircularQueue* obj) 
{
    assert(obj);

    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->data[(obj->Rear+obj->k)%(obj->k+1)];
}

void myCircularQueueFree(MyCircularQueue* obj) 
{
    assert(obj);

    free(obj->data);
    free(obj);
}