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

最新推荐文章于 2024-09-17 14:30:13 发布
最新推荐文章于 2024-09-17 14:30:13 发布
阅读量80 收藏
点赞数
分类专栏： 数据结构初阶 文章标签： 数据结构 算法 leetcode c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70088010/article/details/129657877
版权

⭐博客主页：️CS semi主页
⭐欢迎关注：点赞收藏+留言
⭐系列专栏：数据结构初阶
⭐代码仓库：Data Structure
家人们更新不易，你们的点赞和关注对我而言十分重要，友友们麻烦多多点赞＋关注，你们的支持是我创作最大的动力，欢迎友友们私信提问，家人们不要忘记点赞收藏＋关注哦！！！

队列和栈OJ题

一、有效的括号

（一）题目描述

在这里插入图片描述

（二）解题思路

在这里插入图片描述
我们将s数组里面的左半边括号全部放入栈中，再进行栈的匹配，将栈里面的元素一个一个拿出来存到top里与接下来的s数组进行一个个匹配，匹配不成功则返回false，全都匹配成功则匹配成功，这里的细节是需要将原本写的栈的代码全部粘贴过来，再根据我们需要匹配信息来进行运用这些接口函数。

（三）解题代码

typedef char StackDataType;

typedef struct Stack {
	StackDataType* a;
	int top; // 栈顶
	int capacity; // 容量
}ST;


//初始化
void StackInit(ST* ps);

//压栈
void StackPush(ST* ps, StackDataType x);

//出栈
void StackPop(ST* ps);

//计算栈中有多少个
int StackSize(ST* ps);

//判断栈是否为空
bool StackEmpty(ST* ps);

//销毁
void StackDestroy(ST* ps);

//栈内的元素
StackDataType StackShow(ST* ps);


//初始化
void StackInit(ST* ps) {
	assert(ps);
	//先开辟4个空间
	ps->a = (StackDataType*)malloc(sizeof(StackDataType) * 4);
	if (ps->a == NULL) {
		perror("malloc::ps->a");
		return;
	}
	ps->capacity = 4;
	ps->top = 0; //栈顶后一个位置
	//ps->top = -1; //栈顶本身的位置
}

//压栈
void StackPush(ST* ps, StackDataType x) {
	assert(ps);
	//assert(!(StackEmpty(ps)));

	// 判断是否需要扩容
	if (ps->capacity == ps->top) {
		//扩容
		StackDataType* temp = (StackDataType*)realloc(ps->a, sizeof(StackDataType) * ps->capacity * 2);
		if (temp == NULL) {
			perror("malloc failed");
			return;
		}
		ps->a = temp;
		ps->capacity *= 2;
	}
	
	ps->a[ps->top] = x;
	ps->top++;
}

//出栈
void StackPop(ST* ps) {
	assert(ps);
	assert(!(StackEmpty(ps)));
	ps->top--;
}

//计算栈中有多少个
int StackSize(ST* ps) {
	assert(ps);

	return ps->top;
}

//判断栈是否为空
bool StackEmpty(ST* ps) {
	assert(ps);

	return ps->top == 0;//是空返回false，不是空返回true
}

//销毁
void StackDestroy(ST* ps) {
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

//栈内的元素
StackDataType StackShow(ST* ps) {
	assert(ps);
	return ps->a[ps->top - 1];
}

bool isValid(char * s){
    ST st;
    StackInit(&st);
    while(*s != '\0')
    {
        if(*s == '{' || *s == '(' || *s == '[')
        {
            StackPush(&st, *s);
        }
        else{

            if(StackEmpty(&st)){
                StackDestroy(&st);
                return false;
            }

            char top = StackShow(&st);
            StackPop(&st);
            if((*s == ')' && top != '(')
            || (*s=='}' && top != '{')
            || (*s==']' && top != '['))
            {
                StackDestroy(&st);
                return false;
            }
        }
        ++s;
    }

    bool ret =StackEmpty(&st);
    StackDestroy(&st);
    return ret;

}

二、用队列实现栈

（一）题目描述

在这里插入图片描述

（二）解题思路

在这里插入图片描述
看起来似乎很难，但是我们要仔细思考一下，既然要用两个队列实现一个栈的要求，那我们知道队列是先进先出，也就是从队尾进队头出；而栈是后进先出，也就是都从栈顶进入，都从栈顶出。那我们有一个思路，假设队列中总共有n项数据，我们先将前n-1项数据倒入另一个队列中，不就自然剩下最末尾的元素，我们将它进行pop，拿出来即可。所以我们就可以通过这个想法进行空队列，有数据队列进行不断的更迭，将末尾数据取出来；而此时我们又想插入数据怎么办？那当然是插入到有数据的队列后面了，为什么？因为我们知道，我们要模拟的栈是后进先出，也就是说我们新加入的元素需要下一步就出来，所以我们插入到队列的尾，再进行倒数据进行出末尾数据即可。

（三）解题代码

typedef int QueueDataType;

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

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

//初始化
void QueueInit(Queue* pq); //改变结构体成员就用结构体的指针即可

//销毁链表
void QueueDestroy(Queue* pq);

//进队列
void QueuePush(Queue* pq, QueueDataType x);

//出队列
void QueuePop(Queue* pq);

//计算长度
int QueueSize(Queue* pq);

//判断是否为空
bool QueueEmpty(Queue* pq);

//队头
QueueDataType QueueFront(Queue* pq);

//队尾
QueueDataType QueueBack(Queue* pq);

//初始化
void QueueInit(Queue* pq) {
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

//销毁链表
void QueueDestroy(Queue* pq) {
	assert(pq);
	QNode* cur = pq->head;
	while (cur) {
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

//进队列
void QueuePush(Queue* pq, QueueDataType x) {
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL) {
		perror("malloc failed");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->head == NULL) {//链表内部啥也没有
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
	}
	else {
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
    pq->size++;
}

//出队列
void QueuePop(Queue* pq) {
	assert(pq);
	assert(pq->head != NULL);
	/*QNode* cur = pq->head;
	QNode* next = cur->next;
	free(cur);
	pq->head = next;
	if (pq->head == NULL) {
		pq->tail = NULL;
	}
	pq->size--;*/

	if (pq->head->next == NULL) {
		free(pq->head);
		pq->tail = pq->head = NULL;
	}
	else {
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}

//计算长度
int QueueSize(Queue* pq) {
	assert(pq);
	return pq->size;
}

//判断是否为空
bool QueueEmpty(Queue* pq) {
	assert(pq);
	return pq->head == NULL && pq->tail == NULL;
}

//取队头
QueueDataType QueueFront(Queue* pq) {
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}

//取队尾
QueueDataType QueueBack(Queue* pq) {
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}


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


MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    if(pst == NULL){
        perror("malloc fail");
        return NULL;
    }
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
    return pst;
}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1)){
        QueuePush(&obj->q1, x);
    }
    else{
        QueuePush(&obj->q2, x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* EmptyQ = &obj->q1;
    Queue* NoneEmptyQ = &obj->q2;
    if(!QueueEmpty(&obj->q1)){
        EmptyQ = &obj->q2;
        NoneEmptyQ = &obj->q1;
    }
    //导数据
    while(QueueSize(NoneEmptyQ) > 1){//留最后一个数据
        QueuePush(EmptyQ, QueueFront(NoneEmptyQ));//队列头元素移动
        QueuePop(NoneEmptyQ);
    }
    int top = QueueFront(NoneEmptyQ);
    QueuePop(NoneEmptyQ);
    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) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

三、用栈实现队列

（一）题目描述

在这里插入图片描述

（二）解题思路

在这里插入图片描述

在这里插入图片描述
我们有了前面一题的思路，那其实解决起来这道题目更加地轻松，我们如此规定：右边栈进行pop，左边栈进行push，也就是说，我们刚开始进行push数据的时候，是需要push在左边那个栈的，我们push进去1 2 3 4，而最后是从顶到底4 3 2 1这样的，那我们想要模拟队列，那就需要将4 3 2 1倒入右栈，从栈顶到栈低为1 2 3 4了，那就出栈顶即可，我们继续push也是同理，放在左栈，继续导数据进入右栈，再进行pop即可。

（三）解题代码

typedef int StackDataType;

typedef struct Stack {
	StackDataType* a;
	int top; // 栈顶
	int capacity; // 容量
}ST;

//初始化
void StackInit(ST* ps);

//压栈
void StackPush(ST* ps, StackDataType x);

//出栈
void StackPop(ST* ps);

//计算栈中有多少个
int StackSize(ST* ps);

//判断栈是否为空
bool StackEmpty(ST* ps);

//销毁
void StackDestroy(ST* ps);

//栈顶的元素
StackDataType StackShow(ST* ps);

//初始化
void StackInit(ST* ps) {
	assert(ps);
	//先开辟4个空间
	ps->a = (StackDataType*)malloc(sizeof(StackDataType) * 4);
	if (ps->a == NULL) {
		perror("malloc::ps->a");
		return;
	}
	ps->capacity = 4;
	ps->top = 0; //栈顶后一个位置

	//ps->top = -1; //栈顶本身的位置
}

//压栈
void StackPush(ST* ps, StackDataType x) {
	assert(ps);

	// 判断是否需要扩容
	if (ps->capacity == ps->top) {
		//扩容
		StackDataType* temp = (StackDataType*)realloc(ps->a, sizeof(StackDataType) * ps->capacity * 2);
		if (temp == NULL) {
			perror("malloc failed");
			return;
		}
		ps->a = temp;
		ps->capacity *= 2;
	}
	
	ps->a[ps->top] = x;
	ps->top++;
}

//出栈
void StackPop(ST* ps) {
	assert(ps);
	assert(!(StackEmpty(ps)));
	ps->top--;
}

//计算栈中有多少个
int StackSize(ST* ps) {
	assert(ps);

	return ps->top;
}

//判断栈是否为空
bool StackEmpty(ST* ps) {
	assert(ps);

	return ps->top == 0;//是空返回false，不是空返回true
}

//销毁
void StackDestroy(ST* ps) {
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

//栈顶的元素
StackDataType StackShow(ST* ps) {
	assert(ps);
	return ps->a[ps->top - 1];
}

typedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    if(obj == NULL){
        perror("malloc failed");
        return NULL;
    }
    StackInit(&obj->pushst);
    StackInit(&obj->popst);
    return obj;
}

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

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popst)){
        //导数据
        while(!StackEmpty(&obj->pushst)){
            StackPush(&obj->popst, StackShow(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    return StackShow(&obj->popst);
}

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

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

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->popst);
    StackDestroy(&obj->pushst);
    free(obj);
}

四、设计循环队列

（一）题目描述

在这里插入图片描述

（二）解题思路

在这里插入图片描述
先创建一个循环链表，其中a数组为开辟k+1个int型空间，头和尾都为头元素，也就是size=0的位置；判断数组是否为空仅仅判断头和尾是否相等；判断是否为满很简单，我们因为多开辟了一个区域，直接判断rear+1是否与头相等即可，那有很多朋友就要问了，那越界怎么办，那我们就用取余，将rear始终放在这k+1个空间内即可；关于放入数据这个函数的操作，先要判断这个数组是否已经放满了，没放满就先将数据放到rear当前位置，再将rear++往后走一位，这个往后走一位同样也是需要判断是否越界，直接进行取模操作即可；出数据就是简单的将front往后走即可。

（三）解题代码

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


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->front = obj->rear = 0;
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    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->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-1 + obj->k+1)%(obj->k+1)];
}

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

总结

这四个关于栈和队列的经典OJ题，可谓是经典中的经典，在各大面试中都会考这几道经典题，都用的老的知识，新奇的思想，让我们知道老知识新用的妙处，都哥说过：“少即是多”，我们不能学的很快，学得很多，想要把所有的都在短时间内学完，实际上我们要不断学习旧知识，巩固好旧知识，这样才能成功。

客官，来个三连支持一下吧！

2022horse
关注
专栏目录
swust西南科技大学OJ数据结构80题答案
10-14
在线评测系统（Online Judge，简称OJ）是检验编程能力，特别是算法和数据结构应用能力的常见平台。西南科技大学的OJ提供了80道数据结构相关的题目，旨在帮助学生深入理解和掌握各种数据结构及其应用。 在这个压缩包...
mooc-清华数据结构与算法(邓俊辉) OJ习题.zip
06-17
这个压缩包可能包含了一系列在在线判题系统（Online Judge，简称OJ）上用于检验学习者编程技能和理解的数据结构与算法问题。 【描述】"mooc-清华数据结构与算法(邓俊辉) OJ习题.zip" 暗示这是一个教学资源包，用于...
数据结构与算法(Python版) | (7) 队列、列表OJ作业
12-21
在这篇关于“数据结构与算法(Python版) | (7) 队列、列表OJ作业”的文章中，我们将关注队列这一基本数据结构以及其在解决实际问题中的应用。 首先，我们来看有序队列的问题。有序队列要求队列中的元素按照一定的...
西南科技大学SWUST OJ 数据结构 图相关题题解 图.zip
01-01
SWUST OJ ： 1055、1056、1057、1058、1059、1060、1061、1062、1063、1064、1065、1066、1067、1068、1069、1070、1071、1072、1075、1086题答案
详解数据结构中的链表结构
Zion__的博客
09-14 920
int data;} Node;// 创建新节点// 在链表头部插入节点// 遍历链表= NULL) {// 输出：1 -> 2 -> 3 -> NULLreturn 0;链表是数据结构中的重要部分，尤其在需要动态管理内存或频繁插入、删除操作的情况下，链表比数组具有更好的性能。链表的多种类型（如单向链表、双向链表、循环链表等）为不同的应用场景提供了灵活性，但也因为其随机访问能力较差、操作复杂性高等缺点，在某些场景下可能不如数组高效。
每日学习一个数据结构-B+树
wendao76的专栏
09-14 905
B+树是一种自平衡的树数据结构，广泛应用于数据库和操作系统的索引结构中，特别是在MySQL的InnoDB存储引擎中。它通过保持数据排序，使得搜索、插入、删除等操作都能在对数时间内完成。
【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】
Mao_c的博客
09-14 1022
leetcode b树
Acwing数据结构：单链表
qq_43060884的博客
09-14 554
数组模拟单链表，是不是比结构体好玩？
数据结构—栈
2301_80151359的博客
09-17 358
/定义栈的结构//栈的空间大小int top;//栈顶}ST;
数据结构—队列
最新发布
2301_80151359的博客
09-17 282
QueueNode;int size;//保存队列有效数据个数}Queue;初始化队列。
【高阶数据结构】并查集
qq_67582098的博客
09-14 758
【高阶数据结构】并查集
【数据结构】队列
Sakura_ding的博客
09-14 445
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。入队列：进行插入操作的一端称为队尾。出队列：进行删除操作的一端称为队头。
重头开始嵌入式第四十一天（数据结构 树 哈希表）
qq_64792908的博客
09-14 1388
树：n（n>=0）个结点的有限集合。n = 0 ,空树。在任意一个非空树中，1，有且仅有一个特定的根结点2，当n>1 时，其余结点可分为m个互不相交的有限集合T1,T2,T3.。。。。Tm，其中每一个集合又是一个树，并且称谓子树。结点拥有子树的个数称谓结点的度。度为0的结点称谓叶结点。度不为0，称谓分支结点。树的度数是指，这棵树中，最大的结点的度数，称谓树的度数。树的深度或高度，从根开始，根为第一层，根的孩子为第二层。树的存储，顺序结构，链式结构。
数据结构--图
wxdzuishaui的博客
09-14 257
【代码】数据结构--图。
数据结构：（牛客OR36）链表的回文结构
2303_81073778的博客
09-14 401
对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。给定一个链表的头指针，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。测试样例：1->2->2->1返回：true。
Python 中常见的数据结构（三）
Liu_Bruce的博客
09-11 316
希望这篇文章能够帮助您更好地理解 Python 中常见的数据结构，如果您有任何问题或建议，请随时与我联系。这些数据结构都有其特点和应用场景，我们在实际编程中需要选择合适的数据结构来处理和组织数据。Trie是一种特殊的树形数据结构，Python 中，可以使用。堆是一种特殊的树形数据结构，Python 中，可以使用。Python 中还有一些其他的数据结构，例如。方法从堆中弹出元素，并将其打印出来。在上面的示例中，我们创建了一个名为。在上面的示例中，我们创建了一个名为。的 Trie，然后使用。
数据结构之排序的基本概念
DKPT的博客
09-12 478
排序(Sorting)是指将一组记录（或数据元素）按照某个关键字（或字段）的大小关系进行排列的过程。关键字可以是记录中的一个或多个字段，用于确定记录的排序顺序。
深入理解指针（4）
khjjjgd的博客
09-11 920
如果把函数的指针（地址）作为参数传递给另一个函数 ，当这个指针被用来调用其所指向的函数时，被调用的函数就是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或者条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
【数据结构】5——哈夫曼树（Huffman Tree）
qq_43507078的博客
09-13 1372
哈夫曼树
SWUST OJ数据结构后40题：层次遍历与森林树数量统计
这两个代码示例展示了在数据结构课程中，学生可能会遇到的基础算法和数据结构问题，包括二叉树的建立、遍历以及对森林结构的理解。通过解决这类问题，学生可以加深对二叉树及其操作（如先序遍历和层次遍历）、递归和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

2022horse

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

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

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

打赏作者

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

抵扣说明：

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

余额充值