栈和队列OJ题

1. 用队列实现栈

OJ链接：225. 用队列实现栈 - 力扣（LeetCode）

好的，我们一起来看一下题目，题目是这样说的

思路：使用两个队列，始终保持一个队列为空。当我们需要进行进栈操作时，将数据进入不为空的队列中（若两个都为空，则随便压入一个队列）。当需要进行出栈操作时，将不为空的队列中的数据导入空队列，仅留下一个数据，这时将这个数据返回并且删除即可。判断栈是否为空，即判断两个队列是否同时为空

举个例子，我们将 1，2，3，4 进栈，实际上就是进入其中一个队列 q1 中

如果我们要出栈是不是就是按照 4，3，2，1 的顺序，我们将 1，2，3 push 到第二个队列 q2 中，然后在 q1 中 pop 4 就完成出栈的一步操作

然后我们就可以 push q2 中的 1，2 到 q1 ，这样就可以留一个 3 在 q2 然后 pop q2 就可以完成 3 的出栈操作

以此循环就可以完成出栈的全部操作

下面就是代码实现：

typedef int QDataType;
typedef struct QueueNode
{struct QueueNode* next;QDataType data;
}QNode;typedef struct Queue
{QNode* head;QNode* tail;int size;
}Queue;void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);void QueueInit(Queue* pq)
{assert(pq);pq->size = 0;pq->head = pq->tail = NULL;
}void QueueDestory(Queue* pq)
{assert(pq);QNode* cur = pq->head;while (cur){QNode* del = cur;cur = cur->next;free(del);}pq->size = 0;pq->head = pq->tail = NULL;
}void QueuePush(Queue* pq, QDataType x)
{assert(pq);QNode* newnode = (QNode*)malloc(sizeof(QNode));if (newnode == NULL){perror("malloc fail\n");exit(-1);}else{newnode->data = x;newnode->next = NULL;}if (pq->tail == NULL){pq->head = pq->tail = newnode;}else{pq->tail->next = newnode;pq->tail = newnode;}pq->size++;
}bool QueueEmpty(Queue* pq)
{return pq->tail == NULL && pq->head == NULL;
}void QueuePop(Queue* pq)
{assert(pq);assert(!(QueueEmpty(pq)));if (pq->head->next == NULL){free(pq->head);pq->head = pq->tail = NULL;}else{QNode* del = pq->head;pq->head = pq->head->next;free(del);del = NULL;}pq->size--;
}QDataType QueueFront(Queue* pq)
{assert(pq);assert(!(QueueEmpty(pq)));return pq->head->data;
}QDataType QueueBack(Queue* pq)
{assert(pq);assert(!(QueueEmpty(pq)));return pq->tail->data;
}int QueueSize(Queue* pq)
{assert(pq);return pq->size;
}typedef struct {Queue q1;Queue q2;
} MyStack;MyStack* myStackCreate() {MyStack* obj = (MyStack*)malloc(sizeof(MyStack));QueueInit(&obj->q1);QueueInit(&obj->q2);return obj;}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* noEmpty = &obj->q2;if (!QueueEmpty(&obj->q1)){empty = &obj->q2;noEmpty = &obj->q1;}while (QueueSize(noEmpty) > 1){QueuePush(empty, QueueFront(noEmpty));QueuePop(noEmpty);}int top = QueueFront(noEmpty);QueuePop(noEmpty);return top;
}int myStackTop(MyStack* obj) {if (!QueueEmpty(&obj->q1)){return QueueBack(&obj->q1);}else{return QueueBack(&obj->q2);}
}bool myStackEmpty(MyStack* obj) {return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);}void myStackFree(MyStack* obj) {QueueDestory(&obj->q1);QueueDestory(&obj->q2);free(obj);
}

2. 用栈实现队列

OJ链接：232. 用栈实现队列 - 力扣（LeetCode）

好的，我们一起来看一下题目，题目是这样说的

思路：使用两个栈，第一个栈只用于数据的输入，第二个栈只用于数据的输出。当需要输出数据，但第二个栈为空时，先将第一个栈中的数据一个一个导入到第二个栈，然后第二个栈再输出数据即可

举个例子 ，我想要按照 1，2，3，4 的顺序入队列，那就是要按照 1，2，3，4 的顺序出队列，我们可以先入一个栈，然后将第一个栈中的数据一个一个导入到第二个栈，输入即可

下面就是代码实现：

typedef int STDataType;
typedef struct Stack
{STDataType* _a;int _top; // 栈顶int _capacity; // 容量
}Stack;// 初始化栈
void StackInit(Stack* ps);// 入栈
void StackPush(Stack* ps, STDataType data);// 出栈
void StackPop(Stack* ps);// 获取栈顶元素
STDataType StackTop(Stack* ps);// 获取栈中有效元素个数
int StackSize(Stack* ps);// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps);// 销毁栈
void StackDestroy(Stack* ps);bool StackEmpty(Stack* ps)
{assert(ps);return ps->_top == 0;
}int StackSize(Stack* ps)
{assert(ps);return ps->_top;
}STDataType StackTop(Stack* ps)
{assert(ps);assert(!StackEmpty(ps));return ps->_a[ps->_top - 1];
}void StackInit(Stack* ps)
{assert(ps);ps->_a = NULL;ps->_capacity = ps->_top = 0;
}void StackPush(Stack* ps, STDataType data)
{assert(ps);if (ps->_top == ps->_capacity){int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;STDataType* tmp = (STDataType*)realloc(ps->_a, newCapacity * sizeof(STDataType));if (NULL == tmp){perror("malloc fail");exit(-1);}ps->_a = tmp;ps->_capacity = newCapacity;}ps->_a[ps->_top] = data;ps->_top++;
}void StackPop(Stack* ps)
{assert(ps);ps->_top--;
}void StackDestroy(Stack* ps)
{assert(ps);free(ps->_a);ps->_a = NULL;ps->_capacity = ps->_top = 0;
}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);
}void PushSTToPopST(MyQueue* obj)
{if (StackEmpty(&obj->popST)){while (!StackEmpty(&obj->pushST)){StackPush(&obj->popST, StackTop(&obj->pushST));StackPop(&obj->pushST);}}
}int myQueuePop(MyQueue* obj) {PushSTToPopST(obj);int front = StackTop(&obj->popST);StackPop(&obj->popST);return front;
}int myQueuePeek(MyQueue* obj) {PushSTToPopST(obj);int front = StackTop(&obj->popST);return front;
}bool myQueueEmpty(MyQueue* obj) {return StackEmpty(&obj->popST) && StackEmpty(&obj->pushST);}void myQueueFree(MyQueue* obj) {StackDestroy(&obj->pushST);StackDestroy(&obj->popST);free(obj);
}

3. 括号匹配问题

OJ链接：20. 有效的括号 - 力扣（LeetCode）

好的，我们一起来看一下题目，题目是这样说的

思路：该题是栈的典型应用，满足后进先出的规则（后入栈的前括号将优先与先出现的后括号相匹配）。遍历字符串，遇到前括号直接入栈。遇到后括号，判断该后括号与栈顶的前括号是否匹配（若此时栈为空，则字符串无效），若不匹配则字符串无效；若匹配则删除栈顶元素，继续遍历字符串，直到字符串遍历完毕。当字符串遍历完后，检测栈是否为空，若为空，则字符串有效，若不为空，说明有前括号未匹配，字符串无效

typedef char STDataType;
typedef struct Stack
{STDataType* _a;int _top; // 栈顶int _capacity; // 容量
}Stack;// 初始化栈
void StackInit(Stack* ps);// 入栈
void StackPush(Stack* ps, STDataType data);// 出栈
void StackPop(Stack* ps);// 获取栈顶元素
STDataType StackTop(Stack* ps);// 获取栈中有效元素个数
int StackSize(Stack* ps);// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps);// 销毁栈
void StackDestroy(Stack* ps);bool StackEmpty(Stack* ps)
{assert(ps);return ps->_top == 0;
}int StackSize(Stack* ps)
{assert(ps);return ps->_top;
}STDataType StackTop(Stack* ps)
{assert(ps);assert(!StackEmpty(ps));return ps->_a[ps->_top - 1];
}void StackInit(Stack* ps)
{assert(ps);ps->_a = NULL;ps->_capacity = ps->_top = 0;
}void StackPush(Stack* ps, STDataType data)
{assert(ps);if (ps->_top == ps->_capacity){int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;STDataType* tmp = (STDataType*)realloc(ps->_a, newCapacity * sizeof(STDataType));if (NULL == tmp){perror("malloc fail");exit(-1);}ps->_a = tmp;ps->_capacity = newCapacity;}ps->_a[ps->_top] = data;ps->_top++;
}void StackPop(Stack* ps)
{assert(ps);ps->_top--;
}void StackDestroy(Stack* ps)
{assert(ps);free(ps->_a);ps->_a = NULL;ps->_capacity = ps->_top = 0;
}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{if((*s == ')' && StackTop(&st) != '(')|| (*s == ']' && StackTop(&st) != '[')|| (*s == '}' && StackTop(&st) != '{')){StackDestroy(&st);return false;}StackPop(&st);}}++s;}if(!StackEmpty(&st)){StackDestroy(&st);return false;}return true;
}

4. 循环队列

OJ链接：622. 设计循环队列 - 力扣（LeetCode）

好的，我们一起来看一下题目，题目是这样说的

思路：在环形队列中，队列为空时，队头队尾指向同一个位置。当队列不为空时，队头指向插入的第一个数据，队尾指向最后一个数据的下一个位置。当tail+1等于front时，说明环形队列已满。
注意：环形队列的队尾不能像常规队列中队尾一样指向最后一个数据，如果这样的话，我们将不能区别环形队列的状态是空还是满，因为此时队头和队尾都指向同一个位置。这就意味着，我们必须留出一个空间，这个空间不能存放数据，这样我们才能很好的区别环形队列的状态是空还是满。

实现代码如下：

typedef struct {int* a;int head;int tail;int size;
} MyCircularQueue;bool myCircularQueueIsEmpty(MyCircularQueue* obj) {return obj->head == obj->tail;
}bool myCircularQueueIsFull(MyCircularQueue* obj) {return (obj->tail + 1) % obj->size == obj->head;
}MyCircularQueue* myCircularQueueCreate(int k) {MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));obj->a = (int*)malloc(sizeof(int) * (k+1));obj->head = obj->tail = 0;obj->size = k + 1;return obj;
}bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {if(myCircularQueueIsFull(obj)){return false;}else{obj->a[obj->tail] = value;obj->tail++;obj->tail %= obj->size;return true;}
}bool myCircularQueueDeQueue(MyCircularQueue* obj) {if(myCircularQueueIsEmpty(obj)){return false;}else{obj->head++;obj->head %= obj->size;return true;}
}int myCircularQueueFront(MyCircularQueue* obj) {if(myCircularQueueIsEmpty(obj)){return -1;}else{return obj->a[obj->head];}
}int myCircularQueueRear(MyCircularQueue* obj) {if(myCircularQueueIsEmpty(obj)){return -1;}else{return obj->a[(obj->tail - 1 + obj->size) % obj->size];}
}void myCircularQueueFree(MyCircularQueue* obj) {free(obj->a);free(obj);
}