栈和队列——精选题目

原创 于 2025-11-23 22:23:06 发布 · 791 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构 #c语言

「C++ 40 周年」主题征文大赛（有机会与C++之父现场交流！） 10w+人浏览 470人参与

目录

1.有效的括号

思路：用栈来解决

2.用队列实现栈

思路：用空队列接收非空队列得前top-1个元素，再让最后一个元素出队列即可。

3.用栈实现队列

思路：两个栈：pushST用来入队，popST用来出队

4.设计循环队列

思路：

1.有效的括号

题目链接：
20. 有效的括号 - 力扣（LeetCode）https://leetcode.cn/problems/valid-parentheses/description/题目描述：

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

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。

  2. 左括号必须以正确的顺序闭合。

  3. 每个右括号都有一个对应的相同类型的左括号。

思路：用栈来解决

//定义栈的结构
typedef char STDataType;
typedef struct stack {
	STDataType* arr;
	int top;
	int capacity;
}stack;
//初始化
void STInit(stack* ps)
{
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}
//销毁栈
void STDestroy(stack* ps)
{
	if (ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}
//入栈
void STPush(stack* ps, STDataType x)
{
	assert(ps);
	//判断空间是否足够
	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* temp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
		if (temp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = temp;
		ps->capacity = newCapacity;
	}
	//空间足够
	ps->arr[ps->top++] = x;
}
//判断栈是否为空
bool STEmpty(stack* ps)
{
	assert(ps);
	return ps->top == 0;
}
//出栈
void STPop(stack* ps)
{
	assert(!STEmpty(ps));
	ps->top--;
}
//取栈顶数据
STDataType STTop(stack* ps)
{
	assert(!STEmpty(ps));
	return ps->arr[ps->top - 1];
}
//获取栈中有效元素个数
int STSize(stack* ps)
{
	assert(ps);
	return ps->top;
}


bool isValid(char* s) {
    //借助栈来实现
    stack st;
    STInit(&st);
    char* pi=s;
    while(*pi!='\0')
    {
        if(*pi=='('||*pi=='['||*pi=='{')
        {
            STPush(&st,*pi);
        }
        else{
            if(STSize(&st)==0)
            {
                return false;
            }
            char top=STTop(&st);
            if( (top=='('&&*pi==')') || (top=='['&&*pi==']') || (top=='{'&&*pi=='}') )
            {
                STPop(&st);
            }
            else{
                STDestroy(&st);
                return false;
            }
        }
        pi++;
    }
    bool ret=STEmpty(&st)?true:false;
    STDestroy(&st);
    return ret;
}

2.用队列实现栈

题目链接：
225. 用队列实现栈 - 力扣（LeetCode）https://leetcode.cn/problems/implement-stack-using-queues/description/题目描述：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。

  • int pop() 移除并返回栈顶元素。

  • int top() 返回栈顶元素。

  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

思路：用空队列接收非空队列得前top-1个元素，再让最后一个元素出队列即可。

//定义队列结构
typedef struct QueueNode {
    int data;
    struct QueueNode* next;
} QueueNode;
typedef struct Queue {
    QueueNode* phead;
    QueueNode* ptail;
} Queue;
//队列有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QueueNode* pcur = pq->phead;
	while (pcur!=NULL)
	{
		size++;
		pcur = pcur->next;
	}
	return size;
}


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


MyStack* myStackCreate() {
    MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
    //初始化栈
    pst->q1.phead=pst->q1.ptail=NULL;
    pst->q2.phead=pst->q2.ptail=NULL;
    return pst;
}

void myStackPush(MyStack* obj, int x) {
    QueueNode* newnode=(QueueNode*)malloc(sizeof(QueueNode));
    newnode->data=x;
    newnode->next=NULL;
    //往不为空的队列里插入数据
    if(obj->q1.phead!=NULL)
    {
        obj->q1.ptail->next=newnode;
        obj->q1.ptail=obj->q1.ptail->next;
    }
    else if(obj->q2.phead!=NULL)
    {
	    obj->q2.ptail->next=newnode;
        obj->q2.ptail=obj->q2.ptail->next;
    }
    else {
        obj->q1.phead = obj->q1.ptail = newnode;
    }
}

int myStackPop(MyStack* obj) {
    //找不为空队列
    Queue* emp=&obj->q1;
    Queue* noneEmp=&obj->q2;
    if(obj->q2.phead==NULL)
    {
        emp=&obj->q2;
        noneEmp=&obj->q1;
    }
    //不为空的队列前size-1个数据插入空队列中
    while(QueueSize(noneEmp)>1)
    {
        QueueNode* newnode=(QueueNode*)malloc(sizeof(QueueNode));
        newnode->data=noneEmp->phead->data;
        newnode->next=NULL;
        if (emp->phead == NULL)
        {
	        emp->phead = emp->ptail = newnode;
        }
        else {
	        emp->ptail->next=newnode;
            emp->ptail=emp->ptail->next;
        }
        //出队头
        if (noneEmp->phead == noneEmp->ptail)
        {
	        free(noneEmp->phead);
	        noneEmp->phead = noneEmp->ptail = NULL;
        }
        else {
	        QueueNode* next = noneEmp->phead->next;
	        free(noneEmp->phead);
	        noneEmp->phead = next;
        }
    }
    int top=noneEmp->phead->data;
	free(noneEmp->phead);
	noneEmp->phead = noneEmp->ptail = NULL;
    return top;
}

int myStackTop(MyStack* obj) {
    //找不为空队列
    Queue* emp=&obj->q1;
    Queue* noneEmp=&obj->q2;
    if(obj->q2.phead==NULL)
    {
        emp=&obj->q2;
        noneEmp=&obj->q1;
    }
    //返回不为空队列的队尾
    return noneEmp->ptail->data;
}

bool myStackEmpty(MyStack* obj) {
    return obj->q1.phead==NULL&&obj->q2.phead==NULL;
}

void myStackFree(MyStack* obj) {
    QueueNode* pcur1 = obj->q1.phead;
    while (pcur1)
    {
	    QueueNode* next = pcur1->next;
	    free(pcur1);
	    pcur1 = next;
    }
    obj->q1.phead = obj->q1.ptail = NULL;
    QueueNode* pcur2 = obj->q2.phead;
    while (pcur2)
    {
	    QueueNode* next = pcur2->next;
	    free(pcur2);
	    pcur2 = next;
    }
    obj->q2.phead = obj->q2.ptail = NULL;
    free(obj);
    obj=NULL;
}

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

这里写的有些麻烦，也可以直接套用之前写的队列的代码，必要的地步直接用之前的队列代码里定义的函数即可。

3.用栈实现队列

题目链接：
232. 用栈实现队列 - 力扣（LeetCode）https://leetcode.cn/problems/implement-queue-using-stacks/description/题目描述：

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾

  • int pop() 从队列的开头移除并返回元素

  • int peek() 返回队列开头的元素

  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

思路：两个栈：pushST用来入队，popST用来出队

//定义栈的结构
typedef int STDataType;
typedef struct stack {
	STDataType* arr;
	int top;
	int capacity;
}stack;
//初始化
void STInit(stack* ps)
{
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}
//销毁栈
void STDestroy(stack* ps)
{
	if (ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}
//入栈
void STPush(stack* ps, STDataType x)
{
	assert(ps);
	//判断空间是否足够
	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* temp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
		if (temp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = temp;
		ps->capacity = newCapacity;
	}
	//空间足够
	ps->arr[ps->top++] = x;
}
//判断栈是否为空
bool STEmpty(stack* ps)
{
	assert(ps);
	return ps->top == 0;
}
//出栈
void STPop(stack* ps)
{
	assert(!STEmpty(ps));
	ps->top--;
}
//取栈顶数据
STDataType STTop(stack* ps)
{
	assert(!STEmpty(ps));
	return ps->arr[ps->top - 1];
}
//获取栈中有效元素个数
int STSize(stack* ps)
{
	assert(ps);
	return ps->top;
}


typedef struct {
    stack pushST;
    stack popST;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* pq=(MyQueue*)malloc(sizeof(MyQueue));
    STInit(&pq->pushST);
    STInit(&pq->popST);
    return pq;
}

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

int myQueuePop(MyQueue* obj) {
    //从popST里面出数据
    if(STEmpty(&obj->popST))
    {
        while(!STEmpty(&obj->pushST))
        {
            STPush(&obj->popST,STTop(&obj->pushST));
            STPop(&obj->pushST);
        }
    }
    int top=STTop(&obj->popST);
    STPop(&obj->popST);
    return top;
}

int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->popST))
    {
        while(!STEmpty(&obj->pushST))
        {
            STPush(&obj->popST,STTop(&obj->pushST));
            STPop(&obj->pushST);
        }
    }
    int top=STTop(&obj->popST);
    return top;
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->pushST)&&STEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushST);
    STDestroy(&obj->popST);
    free(obj);
    obj=NULL;
}

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

4.设计循环队列

这里先介绍一下循环队列：

实际中还有⼀种特殊的队列叫循环队列，环形队列首尾相连成环，环形队列可以使用数组实现，也可以使用循环链表实现。但是考虑到使用的空间大小，还是推荐使用数组来实现循环队列。

用数组来实现，所以队列满了的情况就是 (rear+1) % (k + 1)  = front 。

                                 队列为空的情况就是 rear = front 。

题目链接：

622. 设计循环队列 - 力扣（LeetCode）https://leetcode.cn/problems/design-circular-queue/description/题目描述：

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

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

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

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。

  • Front: 从队首获取元素。如果队列为空，返回 -1 。

  • Rear: 获取队尾元素。如果队列为空，返回 -1 。

  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。

  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。

  • isEmpty(): 检查循环队列是否为空。

  • isFull(): 检查循环队列是否已满。

思路：

typedef struct {
    int* arr;
    int front;
    int rear;
    int capacity;
} MyCircularQueue;

//初始化
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pq=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //给arr申请k+1个空间
    pq->arr=(int*)malloc(sizeof(int)*(k+1));
    pq->front=pq->rear=0;
    pq->capacity=k;
    return pq;
}
//向循环队列插入一个元素
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //队列满了
    if((obj->rear+1)%(obj->capacity+1)==obj->front)
    {
        return false;
    }
    obj->arr[obj->rear++]=value;
    obj->rear=(obj->rear)%(obj->capacity+1);
    return true;
}
//从循环队列中删除一个元素
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //先检查队列是否为空
    if(obj->front==obj->rear)
    {
        return false;
    }
    obj->front++;
    obj->front=(obj->front)%(obj->capacity+1);
    return true;
}
// /从队首获取元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if(obj->front==obj->rear)
    {
        return -1;
    }
    return obj->arr[obj->front];
}
//获取队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    if(obj->front==obj->rear)
    {
        return -1;
    }
    int prev=obj->rear-1;
    if(obj->rear==0)
    {
        prev=obj->capacity;
    }
    return obj->arr[prev];
}
//检查循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->rear;
}
//检查循环队列是否已满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1)%(obj->capacity+1)==obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->arr);
    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);
*/

数据结构 栈和队列的应用——经典题目分析
ZY-JIMMY
01-08 2888
目录 1、数制转换 (顺序栈) 2、表达式转换、求值 (顺序栈) 3、字符串逆序输出 (顺序栈) 4、括号匹配算法 (顺序栈) 5、判断字符串是否为回文字符串 (顺序栈、链式栈) 6、两个栈实现一个队列 7、两个队列实现一个栈 顺序栈与链栈的实现完整代码：https://blog.youkuaiyun.com/ZYZMZM_/article/details/85261502 顺序队列、循环队...
用栈实现队列——力扣232
qq_42251157的博客
07-09 425
时间复杂度：push 和 empty 为 O(1)，pop 和 peek 为均摊 O(1)。对于每个元素，至多入栈和出栈各两次，故均摊复杂度为 O(1)。空间复杂度：O(n)。其中 n 是操作总数。对于有 n 次 push 操作的情况，队列中会有 n 个元素，故空间复杂度为 O(n)。
Leetcode：662.Design Circular Queue 设计循环队列
Coding
09-18 1150
Design Circular Queue 设计循环队列 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存...
【数据结构】循环队列
不 良的博客
07-07 4668
队列又称为"先进先出（FIFO）"线性表：插入操作只能在队尾进行，删除操作只能在队首进行。而循环队列是队列的一种特殊形式，循环队列（也被称为环形队列）是一种线性数据结构，其操作表现基于先进先出原则，并且队尾被连接在队首之后以形成一个循环。循环队列固定大小，空间能够重复利用。循环队列可以用数组或者链表实现，那下面我们来分析一下哪种方式更好：当我们想使用链表实现时，假设我们想要开辟的队列长度为k = 4；front表示队头指针，rear表示队尾指针：由上图可知，当rear和front 都指向同一个位置时队列为空
循环队列（C语言）
weixin_54454406的博客
10-28 1793
循环队列（Circular Queue），也被称为环形队列或循环缓冲区，是一种队列数据结构，它具有固定大小的缓冲区，允许在队列的前面和后面插入和删除元素。与普通队列不同，循环队列可以避免浪费存储空间的问题，因为当队列的尾部元素达到缓冲区的末尾时，它可以"循环"到缓冲区的开头。
数据结构--循环队列
lbaihao的专栏
06-10 761
1. 顺序队列的假溢出&循环队列的概念 我们已经明白了队列这种基本数据结构，对于顺序队列而言，其存在已经足够解决大多时候的设计问题了，但是其依旧存在一些缺陷和不足，因为我们的入队和出队操作均是直接在其后面进行结点的链接和删除，这就造成其使用空间不断向出队的那一边偏移，产生假溢出。 什么是假溢出？打一个比方： （示例顺序队列） 回顾一下队列的性质，首先我们有一个顺序队列，这个队列的大小为5，其已经包含了四个元素data1,data2,data3,data4,接着，我们对这个队列进行出队操作，出
栈和队列——相关例题
每天进步一点点！
11-26 2094
栈和队列例题
c++详解栈和队列——及模拟实现stack——queue——例题
最新发布
2301_80687320的博客
04-29 664
我们本次栈和队列的模拟实现不在想c语言中一样从底层出发，而是运用适配器，将运用我们已经学习过的类和对象、模板、vector和list等来模拟实现。适配器的解释：电脑的适配器是将220V的电压转化为电脑所能承受的电压，而在c++中的适配器是将我们现学习过的知识通过整理为一个新的类；在C++中，适配器可以用来使不兼容的接口协同工作。适配器是一个类，它将一个现有的类的接口转换成另一个类的接口。
实验报告——栈和队列的应用.pdf
11-10
栈和队列是两种基本的线性数据结构，它们在计算机科学和编程中有着广泛的应用。栈遵循“后进先出”（LIFO, Last In First Out）的原则，而队列遵循“先进先出”（FIFO, First In First Out）的原则。 1. 回文检测：...
数据结构 - 循环队列
weixin_52952392的博客
10-29 1480
循环队列（Circular Queue），也被称为环形队列，是一种特殊的队列数据结构，其特点在于它的队列元素排列呈环形，队列的头部和尾部相连，形成一个闭环。这种数据结构具有一定的固定大小，一旦队列的尾部追上队列的头部，就会发生循环，即新元素会覆盖队列中最早添加的元素，从而实现了循环利用内存空间的效果。
数据结构 之 循环队列
zealice的博客
09-14 400
队列符合先进先出的原则，循环队列可以持续地往队列里增加元素、减少元素。 以下为例。 MyQueue.h #ifndef MYQUEUE_H #define MYQUEUE_H #include"Customer.h" #include"MyQueue.h" #include using namespace std; template //用类模板 class MyQueue {
数据结构——循环队列
weixin_46246967的博客
04-10 233
/*******简单实现了插入，删除，长度，退出等功能********/ 详情请查询这里：https://www.itdaan.com/blog/2016/12/28/3577aeda4ed237b2c044f29c126b67c7.html
数据结构之循环队列
insistll的博客
10-29 494
队列：其原理就像火车的车厢进出隧道，先进的先出，后进的后出。(first in first out)代码实现如下：package com.ll.dataStruct; /** * <p>Title:MyCycleQueue </p> <p>Description: 循环队列</p> <p>Company: </p> * @author ll * @date 2017-10-29下午17:51
循环队列
chbxw
10-15 281
在循环队列中，我们使用一个数组和两个指针（head 和 tail）。 head 表示队列的起始位置，tail 表示队列的结束位置。 class MyCircularQueue: def __init__(self, k: int): """ Initialize your data structure here. Set the size of the qu...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值