数据结构初阶--栈和队列OJ题

最新推荐文章于 2024-07-18 00:08:52 发布
最新推荐文章于 2024-07-18 00:08:52 发布
阅读量469 收藏 3
点赞数 4
分类专栏： 数据结构初阶 文章标签： 数据结构 c语言 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75233943/article/details/130833641
版权

目录

前言

本篇文章将对部分栈和队列综合运用题进行讲解，以对栈和队列有一个更深层次的理解。

有效的括号

先来看题

思路分析

这里我们采取的方法是将左括号入栈，右括号与栈顶的括号进行比较，如果不匹配，则返回false，当所有括号匹配完则返回true。
但是，这里最后几个测试用例会设置各种各样的坑。
1. 我们在每次取栈顶元素时首先要判空，如果为空则返回false。
2. 在将所有的左括号匹配完后，还需对栈判空，如果不为空，说明还有右括号没有匹配，则返回false。
3. 在取出栈顶元素后别忘了将其删除（pop）。

代码实现

由于代码是c语言版本，必须要自己创建一个栈，所以代码可能会有些冗长。

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int Capacity;
}ST;


bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->Capacity = 0;
	pst->top = 0;
}
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->Capacity = 0;
	pst->top = 0;
}
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->Capacity == pst->top)
	{
		int newCapacity = pst->Capacity == 0 ? 4 : pst->Capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
		}
		pst->a = tmp;
		pst->Capacity = newCapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}
void STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	pst->top--;
}
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	return pst->a[pst->top - 1];
}
int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}


bool isValid(char * s){
    ST pst;
    STInit(&pst);
    int len=strlen(s);
    if(len%2==1)
    return false;
    for(int i=0;i<len;i++)
    {
        if(s[i]=='('||s[i]=='['||s[i]=='{')
        {
            STPush(&pst,s[i]);
        }
        else
        {
            if(s[i]==')')
            {
                if(!STEmpty(&pst))
                {
                    char ch = STTop(&pst);
                    STPop(&pst);
                    if(ch!='(')
                    return false;
                }
                else
                return false;
            }
            if(s[i]==']')
            {
                if(!STEmpty(&pst))
                {
                    char ch = STTop(&pst);
                    STPop(&pst);
                    if(ch!='[')
                    return false;
                }
                else
                return false;
            }
            if(s[i]=='}')
            {
                if(!STEmpty(&pst))
                {
                    char ch = STTop(&pst);
                    STPop(&pst);
                    if(ch!='{')
                    return false;
                }
                else
                return false;
            }
        }
    }
    if(!STEmpty(&pst))
    {
        return false;
    }
    return true;
}

用队列实现栈

先来看题

思路分析

这道题的主体思路就是用两个队列queue1、queue2，先将元素存入queue2，要出栈时将queue2中的元素出队列存入queue1中，剩下一个queue2得队尾元素用于出栈即可。
若不是第一次出栈，则将queue1中的元素出队列存入queue2中，剩下一个queue1得队尾元素用于出栈即可。

代码实现

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

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

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

	return pq->size == 0;
}
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;

	pq->size = 0;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	//先删节点
	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//再删头尾指针
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->ptail == NULL)
	{
		assert(pq->phead == NULL);

		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}

	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	pq->size--;
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);
    assert(!QueueEmpty(pq));

	return pq->phead->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->ptail->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));
    if(obj==NULL)
    {
        perror("malloc fail\n");

    }
    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* EmptyQueue=&obj->q1;
    Queue* NonEmptyQueue=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        EmptyQueue=&obj->q2;
        NonEmptyQueue=&obj->q1;
    }
    while(QueueSize(NonEmptyQueue)>1)
    {
        QueuePush(EmptyQueue,QueueFront(NonEmptyQueue));
        QueuePop(NonEmptyQueue);
    }
    int top=QueueFront(NonEmptyQueue);
    QueuePop(NonEmptyQueue);

    return top;



}

int myStackTop(MyStack* obj) {
    if(QueueEmpty(&obj->q1))
    return QueueBack(&obj->q2);
    else
    return QueueBack(&obj->q1);


}

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

}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);

}

用栈实现队列

先看题

思路分析

主体思路就是将其中一个栈用于放入，另一个栈用于取出，每次出栈元素顺序都会翻转，出栈一次正好和队列顺序相匹配。

注意： 在返回队列开头元素时，应先判断用于取出的栈是否为空，若不为空，则直接将栈顶元素取出即可，若为空，则将用于放入的栈元素全部放入用于取出的栈，再返回栈顶元素。

代码实现

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int Capacity;
}ST;

bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->Capacity = 0;
	pst->top = 0;
}
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->Capacity = 0;
	pst->top = 0;
}
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->Capacity == pst->top)
	{
		int newCapacity = pst->Capacity == 0 ? 4 : pst->Capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
		}
		pst->a = tmp;
		pst->Capacity = newCapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}
void STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	pst->top--;
}
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	return pst->a[pst->top - 1];
}
int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}


typedef struct {
    ST pushst;//放
    ST popst;//取
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    if(obj==NULL)
    {
        perror("malloc fail\n");
        return NULL;
    }
    STInit(&obj->pushst);
    STInit(&obj->popst);

    return obj;

}

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

int myQueuePop(MyQueue* obj) {
    int front=myQueuePeek(obj);
    STPop(&obj->popst);
    return front;
}

int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }

    return STTop(&obj->popst);

}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->pushst)&&STEmpty(&obj->popst);

}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);

    free(obj);

}

设计循环队列

先看题

思路分析

我们首先要考虑一个问题，如何区分满和空？
当队列满或空时，rear和front的下标相同。

为了解决这个问题，我们考虑增加一个空间，不存储任何数据，如果rear+1等于front则满。
在解决这个问题以后，我们再来看其他操作，
假设循环队列存储5个数据，则我们先开辟六个空间。

此时rear==front为空。

那么此时我们该如何判满呢？
比如当front为0，rear为5，此时队列满了，又或者是当rear是2，front是3，此时又满了，似乎只要满足rear+1=front即可，但我们仔细想这样一个问题，数组又没法像链表那样，可以直接从尾部找到头部，所以数组下标如果超出了存储空间，我们取模即可让下标又从头开始往后走，

如何插入数据呢？
这个很简单，只需将值放入下标为rear的位置，再将rear++即可，注意如果超出范围，则需取模，由于小于最大范围取模还是等于它本身，我们干脆每次都取模。

如何删除数据？
我们只需将front++即可，同样要取模。

如何获取队首元素？
很简单，直接返回下标为front的元素即可。

如何获取队尾元素？
队尾元素即为rear前一个下标对应的元素，但存在特殊情况，假设此时rear指向了5，我们应该返回4，如果指向0，应该返回5，但5-1=4，0-1很显然不等于5，所以我们还是考虑用取模的方法，这里直接给出公式了
(rear+k)%(k+1).

代码实现

typedef struct {
    int front;
    int rear;
    int k;
    int* a;

} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));
    obj->front=obj->rear=0;
    obj->k=k;

    return obj;

}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->rear;

}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1)%(obj->k+1)==obj->front;

}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    return false;
    obj->a[obj->rear]=value;
    obj->rear++;

    obj->rear%=(obj->k+1);
    return true;

}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return false;

    obj->front++;
    obj->front%=(obj->k+1);
    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->a[(obj->rear+obj->k)%(obj->k+1)];

}


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

}

以上就是本篇文章全部内容，如有出入，欢迎指正。

偷吃橙子的喵
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
mooc-清华数据结构与算法(邓俊辉) OJ习题.zip
06-17
这个压缩包可能包含了一系列在在线判题系统（Online Judge，简称OJ）上用于检验学习者编程技能和理解的数据结构与算法问题。 【描述】"mooc-清华数据结构与算法(邓俊辉) OJ习题.zip" 暗示这是一个教学资源包，用于...
swust西南科技大学OJ数据结构80题答案
10-14
在线评测系统（Online Judge，简称OJ）是检验编程能力，特别是算法和数据结构应用能力的常见平台。西南科技大学的OJ提供了80道数据结构相关的题目，旨在帮助学生深入理解和掌握各种数据结构及其应用。 在这个压缩包...
【数据结构初阶-oj题】栈和队列的oj题（入门）
BaconZzz的博客
08-19 435
栈会了，队列会了，这些也要会哦。
C语言数据结构初阶(8)----栈与队列OJ题
m0_73096566的博客
03-26 910
C语言数据结构初阶(8)----栈与队列OJ题
【数据结构】栈与队列经典oj题
睿的博客
04-08 915
学会了栈与队列相关知识，快来刷题提升自己吧！
数据结构初阶(用C语言实现简单数据结构)--栈和队列
T_X_Parallel的博客
05-24 349
通过上篇有关顺序表和链表的博客，可以了解到线性表的一些大致特征，这篇博客主要就是来了解线性表中的栈和队列。栈的特点是“先进后出”，队列的特点是“先进下先出”
栈和队列的初阶知识与基础OJ练习
CS_boy的博客
11-01 346
  本文仅使用了两种常见的实现方法——动态数组栈、链队列，如果要看更多的队列和栈的实现方法，可以看我的下面这篇文章中有关队列和栈的部分：图的五种接口的实现，   本文的有关队列和栈的实现均已上传码云，可以来关注呀~：我的Gitee star一下再走啊 文章目录????一、栈????1. 存储结构和接口????️2.初始化栈????️3. 入栈????4.判断栈是否为空????5.出栈????6.返回栈顶元素????7.判断栈的大小????8.销毁队列????二、队列????1.存储结构与接口????2.初
【数据结构初阶】栈和队列
2201_75642960的博客
11-22 1916
队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。通读全文的你肯定收获满满，让我们继续为数据结构学习共同奋进!栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为。队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有。FIFO(First In First Out) 入队列：进行插入操作的一端称为。压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
数据结构初阶之栈和队列--C语言实现
qq_40005416的博客
09-07 727
学习栈和队列之前，首先我们要知道，如果说顺序表和链表只是一种数据在内存中不同的存储结构，那么栈和队列就是对内存空间的不同的管理结构。所以栈和队列都可以用顺序表或者链表实现，不同的存储结构并不影响栈和队列对内存空间的管理，只是在代码实现上会有所不同。下面让我们一起来看看吧。关于栈和队列的概念和结构以及实现部分我们就学习到这里，要想对栈和队列有更深的认识，还需要我们来做一些相关的题目，这里我给大家推荐几道相关的题，大家可以下来自己做一做。括号匹配问题OJ链接ps：用栈来完成。用队列实现栈OJ链接。
数据结构初阶——栈和队列
m0_64607843的博客
05-23 4720
学了顺序表，学了链表不过瘾，那就进来看看栈和队列吧，当饭后水果还是不错滴！！！
数据结构初阶--顺序表和链表
weixin_67916525的博客
02-19 366
顺序表本质上就是数组。但是在此之上，顺序表要求存储的数据必须是连续紧挨着的，不能跳跃。用一段物理地址连续的存储单元依次存储数据元素的线性结构。线性表在逻辑上是线性结构，也就说是连续的一条直线。顺序表的物理结构和逻辑结构是一致的。链表是用指针把一块一块内存链接起来。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
最新发布
铁匠匠匠的博客
07-18 267
可以参考以下视频。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 39
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 873
如有错误，欢迎指出~
HALCON数据结构
qq_44744164的博客
07-17 720
HALCON数据结构
数据结构初阶(C语言）-复杂度的介绍
xiuwoaiailixiya的博客
07-14 1019
在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运行时间。时 间复杂度是衡量程序的时间效率，那么为什么不去计算程序的运行时间呢？1. 因为程序运行时间和编译环境和运行机器的配置都有关系，比如同⼀个算法程序，用⼀个老编译 器进行编译和新编译器编译，在同样机器下运行时间不同。2. 同⼀个算法程序，用⼀个老低配置机器和新高配置机器，运行时间也不同。3. 并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。
【数据结构】详解堆
老师我想进步
07-16 645
升序：建大堆降序：建小堆（1）升序：建大堆【思考】排升序，建小堆可以吗？-- 可以（但不推荐）。首先对 n 个数建小堆，选出最小的数，接着对剩下的 n-1 个数建小堆，选出第二小的数，不断重复上述过程。【时间复杂度】建 n 个数的堆时间复杂度是 O(N)，所以上述操作时间复杂度为 O(N²)，效率太低，关系变得杂乱，尤其是当数据量大的时候，效率就更低。同时堆的价值也没有被体现出来，这样不如用直接排序。排升序，因为数字依次递增，需要找到最大的数字，得建大堆。首先对 n 个数建大堆。
数据结构之细说链表
m0_73634434的博客
07-17 566
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
CCF OJ 1113-括号匹配[栈]
06-09
这是一个栈的经典应用，可以通过栈来判断括号是否匹配。具体做法是遍历字符串，如果遇到左括号则入栈，如果遇到右括号，则判断栈顶元素是否为对应的左括号，如果是则出栈，否则返回false。最后判断栈是否为空，如果为空则说明括号匹配。以下是示例代码： ```cpp #include <iostream> #include <stack> #include <string> using namespace std; bool isMatch(char left, char right) { return (left == '(' && right == ')') || (left == '[' && right == ']') || (left == '{' && right == '}'); } bool check(string s) { stack<char> st; for (char c : s) { if (c == '(' || c == '[' || c == '{') { st.push(c); } else { if (st.empty() || !isMatch(st.top(), c)) return false; st.pop(); } } return st.empty(); } int main() { string s; cin >> s; if (check(s)) { cout << "Yes" << endl; } else { cout << "No" << endl; } return 0; } ``` 以上代码中isMatch函数用于判断左右括号是否匹配，check函数用于检查字符串是否匹配。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

偷吃橙子的喵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值