[LeetCode刷题]栈和队列经典必刷题|有效的括号|栈实现队列|队列实现栈|设计循环队列

⭐️20. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

示例 4：

输入：s = "([)]"
输出：false

示例 5：

输入：s = "{[]}"
输出：true

提示：

• 1 <= s.length <= 104
• s 仅由括号 '()[]{}' 组成

思路

栈

这是用栈解决的经典问题，像这样的对称匹配类问题，用栈来解决就很合适。

思路就是

从左到右遍历字符串，遇到左括号就push一个相应的右括号，遇到右括号就看栈顶元素是否和它相符，相符则pop，不符就返回false。

问题在于判断返回false的条件，上面说的是一种。还有两种分别是

• 栈为空，而还有右括号未遍历
• 遍历完字符串，栈却不为空。

三种情况图示如下：

---

最近学了c语言实现栈和队列[数据结构](6)栈和队列，做这道题不妨先实现一个栈

C代码如下：

typedef char STDataType;

typedef struct Stack {
	STDataType* a;
	int top;		// 栈顶的位置
	int capacity;	// 容量
}ST;

void StackInit(ST* ps) {
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void StackDestory(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;
		ps->a = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));
		if (ps->a == NULL) {
			printf("realloc fail\n");
			exit(-1);
		}
		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 == '(') StackPush(&st, ')');
        else if (*s == '[') StackPush(&st, ']');
        else if (*s == '{') StackPush(&st, '}');
        else if (StackEmpty(&st) || *s != StackTop(&st)) return false;
        else StackPop(&st);
        s++;
    }
    return StackEmpty(&st);
}

优化

其实做这道题代码没必要这么繁。

稍微再想想，如果字符串长度是奇数，那么肯定不可能有效。

bool isValid(char * s){
    int n = strlen(s);
    if (n % 2 == 1) return false;
    char st[n + 1];
    int top = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] == '(') st[top++] = ')';
        else if (s[i] == '[') st[top++] = ']';
        else if (s[i] == '{') st[top++] = '}';
        else if (top == 0 || s[i] != st[top - 1]) return false;
        else top--;
    }
    return top == 0;
}

top初始化为0，指的是栈顶元素后面一个位置，所以数组要多开一个元素的空间，防止越界。

另外这种右括号入栈的方式比左括号入栈的简单，也算是个小技巧。

⭐️225. 用队列实现栈

难度简单468收藏分享切换为英文接收动态反馈

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

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

• 1 <= x <= 9
• 最多调用100 次 push、pop、top 和 empty
• 每次调用 pop 和 top 都保证栈不为空

**进阶：**你能否仅用一个队列来实现栈。

思路

两个队列实现栈

进阶是让我们仅用一个队列，其实个人看来，只用一个队列反而更好理解。

我们先用两个队列试一试。

• 先想想栈与队列有什么不同，栈是先进后出，而队列是先进先出，

• 先让元素按顺序进入栈和队列中。元素出栈时，我们发现，出栈元素就是队尾元素，

• 队列必须把前面的元素全部排出才能排这个元素

• 所以再安排一个队列临时存放前面排出的元素，等队尾元素出队后再放回去。

没办法，还是先实现队列吧。

有详细注释的代码如下：

typedef int QDataType;

typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	assert(newnode);

	newnode->data = x;
	newnode->next = NULL;

	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);

	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;
	}
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

size_t QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	size_t size = 0;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

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;
}
//以上是队列的实现，下面是题目要实现的部分
typedef struct {//我的栈 由两个队列来模拟
    Queue que1;//主队列
    Queue que2;//临时存放队列
} MyStack;

MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));//分配空间，给队列初始化
    QueueInit(&obj->que1);
    QueueInit(&obj->que2);
    return obj;
}

void myStackPush(MyStack* obj, int x) {
    QueuePush(&obj->que1, x);
}

int myStackPop(MyStack* obj) {
    int size = QueueSize(&obj->que1);
    while (--size) { //--size就是循环size - 1次，把元素传进que2，只留队尾元素。
        QueuePush(&obj->que2, QueueFront(&obj->que1));
        QueuePop(&obj->que1);
    }
    int result = QueueFront(&obj->que1);//记录队尾元素并删除
    QueuePop(&obj->que1);
    while (!QueueEmpty(&obj->que2)) { //把que2的元素还给que1
        QueuePush(&obj->que1, QueueFront(&obj->que2));
        QueuePop(&obj->que2);
    }
    return result;
}

int myStackTop(MyStack* obj) {
    return QueueBack(&obj->que1);
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->que1);
}

void myStackFree(MyStack* obj) {
    QueueDestory(&obj->que1);
    QueueDestory(&obj->que2);
    free(obj);
}

一个队列实现栈

其实本质是一样的

只是出栈时，队列前面的元素没必要用第二个队列来存，直接排到队列尾部就行了

实现队列的部分就省去了，不然篇幅太长。

typedef struct {
    Queue que;
} MyStack;

MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->que);
    return pst;
}

void myStackPush(MyStack* obj, int x) {
    QueuePush(&obj->que, x);
}

int myStackPop(MyStack* obj) {
    int size = QueueSize(&obj->que);
    while (--size) {
        QueuePush(&obj->que, QueueFront(&obj->que));
        QueuePop(&obj->que);
    }
    int result = QueueFront(&obj->que);
    QueuePop(&obj->que);
    return result;
}

int myStackTop(MyStack* obj) {
    return QueueBack(&obj->que);
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->que);
}

void myStackFree(MyStack* obj) {
    QueueDestory(&obj->que);
}

⭐️232. 用栈实现队列

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

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

• 1 <= x <= 9
• 最多调用 100 次 push、pop、peek 和 empty
• 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

• 你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

思路

这个必须用两个栈来实现

• 先想想栈与队列有什么不同，栈是先进后出，而队列是先进先出，

• 先让元素按顺序进入队列和栈中。元素出队时，我们发现，出队元素就是栈底元素，

• 栈必须把前面的元素全部排出才能排这个元素

• 所以再安排一个栈存放前面排出的元素。

• 之后要排出元素的顺序，就和这个新的栈的顺序一样。

所以定义两个栈，一个是进栈stIn，一个是出栈stOut

只有在出栈为空时才把进栈的元素给过来，防止中途插入元素导致顺序错误。

这里实现栈的部分就省去了，和上面一样的。

typedef struct {
    ST stIn;
    ST stOut;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* que = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&que->stIn);
    StackInit(&que->stOut);
    return que;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->stIn, x);
}

int myQueuePop(MyQueue* obj) {
    if (StackEmpty(&obj->stOut)) {
        while (!StackEmpty(&obj->stIn)) {
            StackPush(&obj->stOut, StackTop(&obj->stIn));
            StackPop(&obj->stIn);
        }
    }
    int result = StackTop(&obj->stOut);
    StackPop(&obj->stOut);
    return result;
}

int myQueuePeek(MyQueue* obj) {
    int result = myQueuePop(obj); //这里复用上一个函数，比较方便
    StackPush(&obj->stOut, result);
    return result;
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->stIn) && StackEmpty(&obj->stOut);
}

void myQueueFree(MyQueue* obj) {
    StackDestory(&obj->stIn);
    StackDestory(&obj->stOut);
    free(obj);
}

⭐️622. 设计循环队列

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

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

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

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

示例：

MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4

提示：

• 所有的值都在 0 至 1000 的范围内；
• 操作数将在 1 至 1000 的范围内；
• 请不要使用内置的队列库。

思路

这个队列和我们之前写的队列不同，它有元素个数的限制，满了就不能插了。

而循环又是什么意思？

首先这是队列，我们不能像数组删除中间元素一样去移动后面的元素

非循环就意味着队头元素出队后，它原来占据的这块空间不能再被利用，因为后面的元素不能向前移，插入元素又必须从尾部插入。

循环的话就好办了，如果非循环是直线跑道，那么循环就是环形跑道，只要队头和队尾不碰到一起就可以一直插。

---

数组和链表，用哪个实现好呢？

如果用数组，只要双指针记录队头和队尾就好了，数组操作起来也比较简单。

详细注释代码如下：

typedef struct {
    int* a;    //数组
    int front; //队头下标
    int back;  //队尾的后一个元素的下标（左闭右开）
    int k;     //容量
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc((k + 1) * sizeof(int)); //多开一个元素的空间，和第一题的思想一样。
    obj->front = obj->back = 0;
    obj->k = k;
    return obj;
}
//原题给的模板的函数顺序和这里不一样，因为判空和判满在其他函数中有用，所以我把它们移到上面来了
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->back; //因为是左闭右开，所以双指针重合就说明队列为空
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    if ((obj->back + 1) % (obj->k + 1) == obj->front ) return true;//back的指针的下一个就是front，说明队列满了。
    return false;                                                  //注意back在数组末尾的情况，这里取模就可以了。
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj)) return false; //判断是不是满了
    obj->a[obj->back] = value;
    obj->back == obj->k ? obj->back = 0 : obj->back++; //注意back在数组末尾的情况
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) return false;
    obj->front == obj->k ? obj->front = 0 : obj->front++; //出队就是让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;
    return obj->back == 0 ? obj->a[obj->k] : obj->a[obj->back - 1]; //注意back在数组头部的情况
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

总结

通过这四道题，我们简单了解了栈和队列的基本操作和应用。

这些是基础题，但也是不可忽视的。

后续还有更多题目，我们下篇文章见。