数据结构第七讲：栈和队列OJ题

已于 2024-07-29 15:45:44 修改
阅读量271 收藏 11
点赞数 14
分类专栏： 数据结构初阶 文章标签： 数据结构
于 2024-07-29 13:19:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79761834/article/details/140750726
版权

数据结构第七讲：栈和队列OJ题

1.有效的括号

链接: OJ题目链接
在这里插入图片描述

typedef char StackDataType;

typedef struct Stack
{
	StackDataType* arr;//使用一个指针来指向开辟的数组
	int capacity;//保存数组的空间大小
	int top;//指向栈顶
}Stack;

//栈的初始化
void Init(Stack* ps)
{
	assert(ps);

	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}

//栈的销毁
void Destory(Stack* ps)
{
	assert(ps);

	//注意：这个要加上if进行判断，为了确保arr数组不是指向NULL
	if(ps->arr)
		free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}

//栈的插入
void StackPush(Stack* ps, StackDataType x)
{
	assert(ps);

	//因为只有栈的插入才需要开辟空间，所以开辟结点空间不必封装成一个函数
	if (ps->top == ps->capacity)
	{
		//空间不足，需要开辟
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		StackDataType* parr = (StackDataType*)realloc(ps->arr, newcapacity * sizeof(StackDataType));
		if (parr == NULL)
		{
			perror("malloc faile!");
			exit(1);
		}
		ps->arr = parr;
		ps->capacity = newcapacity;
	}
	ps->arr[ps->top++] = x;
}

//栈的删除
void StackPop(Stack* ps)
{
	//栈为NULL时不能删除，栈中没有数据时不能删除
	assert(ps && ps->top);

	--ps->top;
}

//取栈顶元素
StackDataType StackPrint(Stack* ps)
{
	assert(ps && ps->top);

	return ps->arr[--ps->top];
}

//获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;
}

--------------------------------------------------------------------------
//下面才是实现思路
bool isValid(char* s) {
    Stack ps;
    //先对栈进行初始化
    Init(&ps);

    while(*s)
    {
        if(*s=='(' || *s=='{' || *s=='[')
        {
            //三种情况，进行插入
            StackPush(&ps, *s);
        }
        else
        {
            if((ps.top == 0) || (ps.top==0 && *s!='\0')) return false;
            StackDataType a = StackPrint(&ps);
            if( (a=='(' && *s==')') ||  
                (a=='[' && *s==']') ||
                (a=='{' && *s=='}') );
            else
            {
                //不匹配时，直接返回false
                return false;
            }
        }
        s++;
    }
    if(ps.top!=0 && *s=='\0') return false;
    return true;
}

2.用队列实现栈

链接: OJ题目链接
在这里插入图片描述
在这里插入图片描述

//结点结构体
typedef int QueueDataType;

typedef struct QueueNode
{
	//和链表一样，也需要结点进行链接
	QueueDataType val;
	struct QueueNode* next;
}QueueNode;

//队列结构体
typedef struct Queue
{
	QueueNode* head;//指向队列的头部，方便删除数据
	QueueNode* tail;//指向队列的尾部，方便插入数据
	int size;//用来记录有效数据的个数
}Queue;

//队列初始化
void Init(Queue* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

//销毁队列
void Destory(Queue* pq)
{
	assert(pq);

	QueueNode* prev = pq->head;
	while (prev)
	{   
        QueueNode* next = prev->next;
		free(prev);
		prev = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

//入队列
void QueuePush(Queue* pq, QueueDataType x)
{
	assert(pq);

	//只有入队列需要开辟结点空间
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc faile!");
		exit(1);
	}
	newnode->val = x;
	newnode->next = NULL;
	//要分情况讨论：当队列一开始没有一个结点时
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		//直接插入到末尾即可
		//head ... tail newnode
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}

//出队列
void QueuePop(Queue* pq)
{
	assert(pq && pq->head);

	//出队列要求从队列开头进行删除
	//此时要分情况讨论：当只具有一个结点时
	if (pq->head == pq->tail)
	{
		free(pq->head);
		pq->head = pq->tail == NULL;
	}
	else
	{
		//pq->head pq->head->next
		QueueNode* tmp = pq->head->next;
		free(pq->head);
		pq->head = tmp;
	}
	--pq->size;
}

//取队列头结点数据
QueueDataType QueueFront(Queue* pq)
{
	assert(pq && pq->head);

	return pq->head->val;
}

//取队列尾节点数据
QueueDataType QueueBack(Queue* pq)
{
	assert(pq && pq->head && pq->tail);

	return pq->tail->val;
}

//队列有效元素的个数
int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

//检查队列是否为空
bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->head == NULL;
}
///
typedef struct {
    //需要创建两个队列
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    Init(&pst->q1);
    Init(&pst->q2);

    return pst;
}

void myStackPush(MyStack* obj, int x) {
    //将数据压入栈，首先要找到那个不为空的队列
    //假设第一个队列不为空
    Queue* none = &obj->q1;
    Queue* emp = &obj->q2;
    if(QueueEmpty(&obj->q1))
    {
        none = &obj->q2;
        emp = &obj->q1;
    }
    QueuePush(none, x);
}

int myStackPop(MyStack* obj) {
    //出栈
    Queue* none = &obj->q1;
    Queue* emp = &obj->q2;
    if(QueueEmpty(&obj->q1))
    {
        none = &obj->q2;
        emp = &obj->q1;
    }
    //先将size-1个数据保存到空的队列中
    while(QueueSize(none) > 1)
    {
        int data = QueueFront(none);
        QueuePush(emp, data);
        QueuePop(none);
    }
    int data = QueueFront(none);
    QueuePop(none);
    return data;
}

int myStackTop(MyStack* obj) {
    //取栈顶元素
    Queue* none = &obj->q1;
    Queue* emp = &obj->q2;
    if(QueueEmpty(&obj->q1))
    {
        none = &obj->q2;
        emp = &obj->q1;
    }
    return QueueBack(none);
}

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

void myStackFree(MyStack* obj) {
    Destory(&obj->q1);
    Destory(&obj->q2);
    free(obj);
    obj = NULL;
}

3.用栈实现队列

链接: OJ题目链接
在这里插入图片描述
在这里插入图片描述

typedef int StackDataType;

typedef struct Stack
{
	StackDataType* arr;//使用一个指针来指向开辟的数组
	int capacity;//保存数组的空间大小
	int top;//指向栈顶
}Stack;

//栈的初始化
void Init(Stack* ps)
{
	assert(ps);

	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}

//栈的销毁
void Destory(Stack* ps)
{
	assert(ps);

	//注意：这个要加上if进行判断，为了确保arr数组不是指向NULL
	if(ps->arr)
		free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}

//栈的插入
void StackPush(Stack* ps, StackDataType x)
{
	assert(ps);

	//因为只有栈的插入才需要开辟空间，所以开辟结点空间不必封装成一个函数
	if (ps->top == ps->capacity)
	{
		//空间不足，需要开辟
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		StackDataType* parr = (StackDataType*)realloc(ps->arr, newcapacity * sizeof(StackDataType));
		if (parr == NULL)
		{
			perror("malloc faile!");
			exit(1);
		}
		ps->arr = parr;
		ps->capacity = newcapacity;
	}
	ps->arr[ps->top++] = x;
}

//栈的删除
void StackPop(Stack* ps)
{
	//栈为NULL时不能删除，栈中没有数据时不能删除
	assert(ps && ps->top);

	--ps->top;
}

//取栈顶元素
StackDataType StackPrint(Stack* ps)
{
	assert(ps && ps->top);

	return ps->arr[ps->top-1];
}

//获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;
}

//检查栈是否为空
bool StackCheck(Stack* ps)
{
    assert(ps);

    return ps->top == 0;
}
/
typedef struct {
    //首先要创建出两个栈结构体
    Stack push;
    Stack pop;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* queue = (MyQueue*)malloc(sizeof(MyQueue));

    Init(&queue->push);
    Init(&queue->pop);

    return queue;
}

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

int myQueuePop(MyQueue* obj) {
    //删除元素要在pop队列中删除
    //此时要进行讨论
    //当pop链表还不为空时，直接删除一个元素即可
    if(!StackCheck(&obj->pop))
    {
        int data = StackPrint(&obj->pop);
        StackPop(&obj->pop);
        return data;
    }
    //当pop链表为空时，需要将push链表中的数据移到pop链表中
    //先将元素全部移到pop队列中
    while(!StackCheck(&obj->push))
    {
        int data = StackPrint(&obj->push);
        StackPush(&obj->pop, data);
        StackPop(&obj->push);
    }
    //然后删除pop中的一个元素即可
    int data = StackPrint(&obj->pop);
    StackPop(&obj->pop);
    return data;
}

int myQueuePeek(MyQueue* obj) {
    //返回队列开头的元素
    //此时也要进行检查
    if(!StackCheck(&obj->pop))
    {
        return StackPrint(&obj->pop);
    }
    //当pop链表为空时，需要将push链表中的数据移到pop链表中
    //先将元素全部移到pop队列中
    while(!StackCheck(&obj->push))
    {
        int data = StackPrint(&obj->push);
        StackPush(&obj->pop, data);
        StackPop(&obj->push);
    }
    return StackPrint(&obj->pop);
}

bool myQueueEmpty(MyQueue* obj) {
    //检查队列是否为空
    return StackCheck(&obj->push) && StackCheck(&obj->pop);
}

void myQueueFree(MyQueue* obj) {
    Destory(&obj->push);
    Destory(&obj->pop);
    free(obj);
    obj = NULL;
}

4.设计循环队列

链接: OJ题目链接
要区分队列已满和队列中无数据就要多开辟一块空间，而且那一块空间也是又意义的

在这里插入图片描述

在这里插入图片描述

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


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* tmp = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //需要多创建一个int字节的空间，因为后边还要使用
    tmp->arr = (int*)malloc(sizeof(int) * (k+1));
    tmp->front = tmp->rear = 0;
    tmp->capacity = k;

    return tmp;
}

//判断循环队列是否已满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear + 1) % (obj->capacity + 1) == obj->front;
}

//判断队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->rear == obj->front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //当队列已满时不能进行插入数据
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    //当循环队列不满时，在rear位置插入数据即可
    obj->arr[obj->rear++] = value;
    //如果rear的结果超出了数组的大小，要对rear的值进行一个更正
    obj->rear %= (obj->capacity+1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //删除数据时直接移动front的指向即可
    //当队列为空时不能够执行删除操作
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    //对front的位置进行校正
    obj->front %= (obj->capacity+1);

    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->arr[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    int prev = obj->rear - 1;
    if (prev < 0)
    {
        prev = obj->capacity;
    }
    return obj->arr[prev];
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->arr);
    free(obj);
    obj = NULL;
}
爆炒脑仁
关注
  • 14
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构:栈和队列详解和相关oj题
qq_62274623的博客
06-13 1198
栈队列超详细解答,欢迎阅读
数据结构：栈和队列的实现附上源代码（C语言版）
2301_79171011的博客
02-27 1263
这篇文章是关于栈和队列的C语言实现，干货满满，大家可以边看边手写代码，最后附上栈和队列的参考代码。栈和队列的实现其实相较于链表的实现简单一些，是因为其结构的特殊要求。之后会出一篇关于栈和队列的OJ题目。多多重复，百炼成钢！创作不易，希望这篇文章能给你带来启发和帮助，如果喜欢这篇文章，请留下你的三连，你的支持的我最大的动力！！！
数据结构：栈与队列之迷宫（详解）
study_jiang_up的博客
11-18 4166
迷宫对于数据结构的萌新来说，是比较困难的。所以需要多理解栈和队列的思想，在看这个之前，可以先做做栈和队列其他题目，比如转进制转化等问题，再回来写迷宫问题会更好理解。
C语言【数据结构】栈和队列【OJ题（C++）、选择题】
冰果滴的博客
06-12 2221
目录一.OJ题1.225. 用队列实现栈2.232. 用栈实现队列3.622. 设计循环队列4.20. 有效的括号二.选择题1.下列关于栈的叙述正确的是（B）2.一个栈的入栈序列为ABCDE，则不可能的出栈序列为（D）3.链栈与顺序栈相比，比较明显的优点是（C）4.下列关于用栈实现队列的说法中错误的是（B）5.用无头单链表存储队列，其头指针指向队头结点，尾指针指向队尾结点，则在进行出队操作时（C）6.以下不是队列的基本运算的是（B）7.下面关于栈和队列的说法中错误的是（AB）8.下列关于顺序结构实现循环队列
数据结构_第六关：栈和队列（栈）
weixin_60630270的博客
04-05 422
栈的定义、声明和实现，附源代码，使用栈的OJ题练习
栈和队列Oj习题
qq_52699147的博客
03-29 458
顺序栈 #include<bits/stdc++.h> using namespace std; const int StackSize = 5; //顺序栈的最大长度（请勿改动） template <class T> //定义模板类SeqStack class SeqStack { public: SeqStack(); //构造函数，栈的初始化 ~SeqStack(); //析构函数 void Pus
栈和队列的初阶知识与基础OJ练习
CS_boy的博客
11-01 371
  本文仅使用了两种常见的实现方法——动态数组栈、链队列，如果要看更多的队列和栈的实现方法，可以看我的下面这篇文章中有关队列和栈的部分：图的五种接口的实现，   本文的有关队列和栈的实现均已上传码云，可以来关注呀~：我的Gitee star一下再走啊 文章目录????一、栈????1. 存储结构和接口????️2.初始化栈????️3. 入栈????4.判断栈是否为空????5.出栈????6.返回栈顶元素????7.判断栈的大小????8.销毁队列????二、队列????1.存储结构与接口????2.初
【数据结构】栈和队列的实现及应用
学了就忘是正常现象
08-18 3588
栈和队列
数据结构（Java）：队列&Queue集合&力扣面试OJ题
2401_83595513的博客
07-12 3007
Queue、Deque、栈与队列的相互转换
oj题.zip
10-18
每一道题目都可能包含多种解题策略，如动态规划、贪心算法、回溯、深度优先搜索、广度优先搜索、链表操作、二叉树操作、字符串处理、图论以及基本的数据结构如数组、栈、队列、哈希表等。通过深入研究这些解决方案，...
swust oj.rar_oj.swust_swust oj答案_swust oj 第580题_swust oj 答案_swu
09-24
3. **数据结构**：根据问题特点选择合适的数据结构，如数组、链表、栈、队列、树、图等。 4. **时间复杂度和空间复杂度分析**：评估算法的效率，确保在给定限制下能够及时运行并完成任务。 5. **代码实现**：编写...
栈和队列经典OJ题
MEANSWER的博客
10-05 507
栈和队列经典OJ题1. LeetCode第225题---用队列实现栈2. LeetCode第232题---用栈实现队列3. LeetCode第20题---有效的括号4. LeetCode第150题---逆波兰表达式5. LeetCode第155题---最小栈6. 牛客网剑指offer21题---栈的压入、弹出序列 1. LeetCode第225题—用队列实现栈 链接: https://leetcode-cn.com/problems/implement-stack-using-queues/ 题解：用队列
栈队列OJ题分享及讲解
m0_69888254的博客
08-07 620
从今天开始后面的OJ题，我一致用C++来带大家实现，这需要大家先去了解C++STL里面的容器，以及相关的接口。 ## 1、有效的括号 ![在这里插入图片描述](https://img-blog.csdnimg.cn/24f0768e6bc348d7a19e9bb92750f371.png#pic_center) 这题是比较典型的用栈实现的题目，给了我们一个字符串s，让我们去判断里面的括号是否一一匹配。 **解题思路：** ```cpp class Solution { public: bool i
【数据结构入门】二叉树之堆排序及链式二叉树
KevinRay_0854的博客
08-27 1029
堆排序是一种使用堆数据结构的排序算法。堆是一种完全二叉树，且满足堆属性，即每个节点的值都大于（或小于）它的子节点的值。 二叉树的遍历有三种方式：前序遍历、中序遍历、后序遍历。这三种遍历方式都是深度优先遍历。
【笔记】数据结构——8月27日
m0_52024881的博客
08-27 1359
考研用笔记
数据结构——顺序表
m0_61965705的博客
08-27 603
例如：查找顺序表中的某个元素所在下标，就可以使用ForeachSeqList函数，搭配FindData函数传参对遍历到的数据进行操作。如果要存放字符串类型的，最好写成以下形式。空间可以不连续，访问元素方便。
【数据结构】-----哈希
最新发布
m0_73470633的博客
08-29 1693
一文看懂哈希结构！
数据结构—顺序表
qq_43344188的博客
08-27 428
数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。数据量增长与程序所占用空间的比例关系称为空间复杂度。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。1.空间可以不连续，访问元素不方便。程序 = 数据结构 + 算法。4.链表的插入和删除效率很高。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值