《数据结构学习笔记---第七篇》---栈和队列的OJ练习

已于 2024-03-31 20:27:52 修改
阅读量171 收藏
点赞数 6
分类专栏： 数据结构学习 文章标签： 数据结构 学习 笔记 c语言 c++
于 2024-03-29 21:49:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yl1509797225/article/details/137153798
版权

目录

1. 括号匹配问题。OJ链接

2. 用队列实现栈。OJ链接

3. 用栈实现队列。OJ链接

1. 括号匹配问题。OJ链接

step1:思路分析 ：

1.括号匹配，我们首先考虑用栈实现，我们通过符号栈帧的思想知道，求前中后缀表达式的时候用的就是栈帧，操作数栈和符号栈。

2.根据常见的情况 考虑怎么使用栈，首先我们以示例2为例——“（）{} []”，如果我们用栈我们可以先考虑把“（或 {或[ ” 压入栈中  遇到“）或 } 或  】”就停下来 进行匹配，例如本例就是我们将栈中的（和字符串中的）进行匹配，后续相同，即可说明是匹配的。如果是（（{{[[]]}} ) )这样看起来就很复杂，但是其实我们先把（（{{[[压入栈中，又将]]}} ) )与pop出的栈顶元素匹配，此时也是匹配的，所以满足。但如果是{(}){]{这种情况 ，很明显我们现将{（ 压入栈中，然后发现栈顶（与字符串第一个是} 不匹配，即可说明不满足。

step2. 实现代码：


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

void StackInit(ST*ps);

void StackDestroy(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);

STDataType StackTop(ST* ps);
//返回栈顶元素
bool StackEmpty(ST* ps);
//判空
int  StackSize(ST* ps);

bool StackEmpty(ST* ps)
{
	assert(ps);

	/*if (ps->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	return(ps->top == 0);
}

void StackInit(ST* ps)
{
	assert(ps);
	//创建一个节点空间类似顺序表；
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
		
	}
	ps->top = 0;
	ps->capacity = 4;
}
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackPush(ST* ps, STDataType x)

{
	assert(ps);
	if (ps->top == ps->capacity)//判断是否栈满  需要扩容
	{
		STDataType* tmp = (STDataType*)realloc(ps->a,sizeof(STDataType) * ps->capacity*2);
		if (tmp == NULL)
		{
			perror("melloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;

	}
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	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=='['||*s=='{'||*s=='(')
        {
            StackPush(&st,*s);
            s++;//字符串后移一个单位
        }
        else
        {
            if(StackEmpty(&st))
            {
                StackDestroy(&st);//防止内存泄漏
                return false;
            }
           //前面已经返回了所以这里并不需要else
                char top = StackTop(&st);
                StackPop(&st);//出栈操作  不能忘取值不代表出栈；
                if((*s==']'&&top !='[')||(*s=='}'&&top !='{')||(*s==')'&&top !='('))
                {
                    StackDestroy(&st);//防止内存泄漏
                    return false ;
                }

                else
                {
                    ++s;
                }
        }
    }
    bool ret =StackEmpty(&st);
    StackDestroy(&st);//防止内存泄漏
    return ret;
}

2. 用队列实现栈。OJ链接

 step1:思路分析 ：

1.考虑到栈的特型，无非就是后进先出，那么队列是先进先出，我们想要实现压栈操作，其实和入队是一样的，那么我们将Queue1压入，例如压入123456.那么我们想要实现出栈操作就必须要pop出6，我们此时还有第二个队列，我们可以将12345出队，送入Queue2，再将Queue1当做栈顶元素pop出就可以了。但此时我们也要注意如果在进行压栈操作就必须是银压入Queue2了。

step2. 实现代码：


typedef int QDataType;
typedef struct QueueNode {//创建队列结点
	QDataType data;
	struct QueueNode* next;//别学了单链表 就不会类比其他特殊链表结点的创建
	
}QNode;
typedef struct Queue {//创建队列 指针结构体
	QNode* head;
	QNode* tail;
	int size;
}Queue;

void QueueInit(Queue* ps);
void QueueDestroy(Queue* ps);
void QueuePush(Queue* ps, QDataType x);
void QueuePop(Queue* ps);
void QueuePrint(Queue* ps);
//返回队头队尾元素
QDataType Queuefront(Queue* ps);
QDataType Queueback(Queue* ps);

bool QueueEmpty(Queue* ps);
int QueueSize(Queue* ps);


void QueueInit(Queue* ps)
{
	assert(ps);
	ps->head = NULL;
	ps->tail = NULL;
	ps->size = 0;
}
void QueueDestroy(Queue* ps)
{
	assert(ps);
	QNode* cur = ps->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	ps->head = NULL;
	ps->tail = NULL;
	ps->size = 0;

}
void QueuePush(Queue* ps, QDataType x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (ps->tail == NULL)
	{
		ps->tail = ps->head = newnode;
	}
	else
	{
		ps->tail->next = newnode;
		ps->tail = newnode;
	}
	ps->size++;
	
}
void QueuePrint(Queue* ps)
{
	if (ps == NULL)

	{
		printf("NULL\n");
	}
	QNode* cur = ps->head;
	while (cur)
	{
		QNode* next = cur->next;
		printf("%d->", cur->data);
		cur = next;
	}
	printf("NULL\n");
}
void QueuePop(Queue* ps)
{
	assert(ps);
	assert(!QueueEmpty(ps));
	if (ps->head->next == NULL)
	{
		free(ps->head);
		ps->head = NULL;
		ps->tail = NULL;
		ps->size = 0;
	}
	else {
		
		QNode* del = ps->head;
		
		ps->head = ps->head->next;
		free(del);
		ps->size--;
	}
}
//返回队头队尾元素
QDataType Queuefront(Queue* ps)
{
	assert(ps);
	assert(!QueueEmpty(ps));
	return (ps->head->data);
	
}
QDataType Queueback(Queue* ps)
{
	assert(ps);
	assert(!QueueEmpty(ps));
	return (ps->tail->data);
}

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

	return ps->head == NULL && ps->tail == NULL;
}
int QueueSize(Queue* ps)
{
	assert(ps);
	
	return (ps->size);
}




typedef struct {
 Queue q1; //栈的结构体里面定义两个队列
 Queue q2;
} MyStack;


MyStack* myStackCreate() {
     MyStack*obj=(MyStack*)malloc(sizeof(MyStack));
     QueueInit(&obj->q1);
     QueueInit(&obj->q2);
     return obj;
}

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


void myStackFree(MyStack* obj) {
      QueueDestroy(&obj->q1);
      QueueDestroy(&obj->q2);
      free(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*emptyQ=&obj->q1;
    Queue*nonemptyQ=&obj->q2;
    
    if(!QueueEmpty(&obj->q1))
     {
        emptyQ=&obj->q2;
        nonemptyQ=&obj->q1;
     }
     while(QueueSize(nonemptyQ)>1)
     {
         QueuePush(emptyQ,Queuefront(nonemptyQ));
         QueuePop(nonemptyQ);
     }
     int top=Queuefront(nonemptyQ);
     QueuePop(nonemptyQ);
     return top;
     
}

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

3. 用栈实现队列。OJ链接

 step1:思路分析 ：

1.考虑到队列先进先出，我们可以让元素先压入Stack1中例如123456，那么我们想要得到对头元素，我们可以将StackPop出来，65432放入栈Stack2中，取Stack1栈顶元素即可。

2.那么接下来Stack2里面有65432，我们要是在再压入789，我们如何得到队首元素呢？有一种方法就是如果我们把65432pop回栈1中，然后插入789，再pop回栈2，这样是不是有些麻烦了。

3.但是如果我们把栈1定义为入栈，把栈2定义为出栈，我们可以继续吧789压入栈1，然后栈2的元素继续pop因为此时栈2的出栈顺序刚好满足出队的顺序。

step2. 实现代码：

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

void StackInit(ST*ps);

void StackDestroy(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);

STDataType StackTop(ST* ps);
//返回栈顶元素
bool StackEmpty(ST* ps);
//判空
int  StackSize(ST* ps);




void StackInit(ST* ps)
{
	assert(ps);
	//创建一个节点空间类似顺序表；
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
		
	}
	ps->top = 0;
	ps->capacity = 4;
}
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackPush(ST* ps, STDataType x)

{
	assert(ps);
	if (ps->top == ps->capacity)//判断是否栈满  需要扩容
	{
		STDataType* tmp = (STDataType*)realloc(ps->a,sizeof(STDataType) * ps->capacity*2);
		if (tmp == NULL)
		{
			perror("melloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;

	}
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}
bool StackEmpty(ST* ps)
{
	assert(ps);

	/*if (ps->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	return(ps->top == 0);
}
int  StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}



typedef struct {
    ST Pushq;
    ST Popq;
    
} MyQueue;
bool myQueueEmpty(MyQueue* obj);

MyQueue* myQueueCreate() {
    MyQueue*ps=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&ps->Pushq);
    StackInit(&ps->Popq);
    return ps;
    
}
bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->Popq)&&StackEmpty(&obj->Pushq);
}
int myQueuePeek(MyQueue* obj) {
     assert(obj);
     assert(!myQueueEmpty(obj));
   if(StackEmpty(&obj->Popq))
    {
        while(!StackEmpty(&obj->Pushq))
        {
             StackPush(&obj->Popq,StackTop(&obj->Pushq));
             StackPop(&obj->Pushq);
        }
        
    }
    return StackTop(&obj->Popq);
}

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

int myQueuePop(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(obj));
    int peek=myQueuePeek(obj);
    StackPop(&obj->Popq);
    return peek;
}

void myQueueFree(MyQueue* obj) {
   assert(obj);
    StackDestroy(&obj->Popq);
      StackDestroy(&obj->Pushq);
      free(obj);
}

小黑码bit
关注
  • 6
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现oj算法代码-贪心算法.zip
10-28
C++实现oj算法代码---贪心算法
数据结构笔记（王道考研） 第五章：树和二叉树
zimuzi2019的博客
08-10 2508
数据结构笔记（王道考研） 第五章：树和二叉树
【数据结构 Java 版】详解栈和队列的实现，如何搞定面试
2401_84438292的博客
04-21 748
现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份Java并发体系思维导图，希望对你有所帮助。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
数据结构学习笔记汇总（适合初学者）
藏宝大厦
03-27 1116
写在最开始的那段话： 整理完了对于C语言基础和一些提升部分的笔记内容，真的是感觉自己漏洞百出，不整理不知道，一整理吓一跳，对于以前很多的知识点都在忘记，所以也是赶快将这最重要的数据结构捡起来，通过以前的笔记和一些代码，将这些内容整理出来，方便自己，也方便初学者的朋友们，还是那句话，有则改之无则加勉！ 文章目录序1.什么是数据结构？2. 什么是算法？第一节：时间复杂度和空间复杂度1. 算法效率2. ...
Java版数据结构与算法笔记
QWQ___qwq的博客
02-01 844
:front并没有直接指向数据,而是数据前一位,所以当你要用front读取队列头时需要代码实现 问题分析与优化方向: 目前数组使用一次就不能用， 没有达到复用的效果. ​ :取出数据时是将列表头()向后移动,导致队列前面的空间并没有被释放,如上图第三个队列示例图初始化为0:因为要指向队列第一个位置,所以为0队列满条件:–>原理如上方环形队列示例图队列为空:假使你队列曾经加到8个数据,所以你,但当你将队列一个一个取出时front发生如下变化:,所以当frontrear8时,就可以判断队列为空队列的有效
冬至·特辑：Note4---二叉树的链式结构
2301_79184587的博客
12-22 1084
本篇博客，小江带领大家一起学习如何实现二叉树的链式结构+二叉树的性质总结+涉及上篇博客和这篇博客的知识点一些选择题来巩固基础
数据结构学习笔记
tao77777的博客
03-09 138
c语音数据结构入门
《代码随想录1-7章》二刷题解及心得体会
qq_44732492的博客
03-15 1618
0 前言   昨天结束了《代码随想录》一刷（只看不上机操作，目的是对算法建立初步的认识），历时一个多月。在第一遍阅读之后，有许多不理解的地方，在书中用问号标识。第二遍阅读本书目的就是想通过上机训练将之前的疑惑解开。另外，本书题解和内容仍有一小部分错误，希望在此更正。 1 第一章 面试要知己知彼   本章主要介绍面试流程、如何写简历及代码规范。本书中的C++代码严格按照Google C++编程规范：     1.操作符左右一定有空格。     2.分隔符（,和;)的前一位没有空格，后一位有空格。     3.
【C++】拆分详解 - 类与对象
bubble_shadow的博客
03-27 984
/ 类体：由成员函数和成员变量组成// 一定要注意后面的分号class为定义类的关键字ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数。声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加一般情况下，更期望采用第二种方式。
算法竞赛宝典3-基础数据结构
07-23
资源名称：算法竞赛宝典3-基础数据结构资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
OJ系统汇总-2021-10-5(C)-32页.pdf
10-05
OJ系统汇总-2021-10-5(C)-32页.pdf
OJ系统汇总-2021-10-5(B).pdf
10-05
OJ系统汇总-2021-10-5(B).pdf
A2OJ-Ladder:A2OJ梯形图复选框
03-19
A2OJ-梯子选框ID姓名问题计数完毕11 100完毕12 100完毕13 100完毕14 100完毕15 100完毕16 100完毕17 100完毕18岁 100完毕19 100完毕20 100完毕21岁 100完毕22 200完毕23 200完毕24 200完毕25 200完毕26 200完毕27 ...
数据结构-栈
2302_81705247的博客
05-02 957
栈底层逻辑的理解和模仿实现。逆波兰表达式
顺序表的实现（迈入数据结构的大门）（2）
最新发布
老师我想进步
05-09 295
书接上文。
数据结构（四）抽象数据类型
无人罪的博客
05-09 242
线性结构（一对一）：数组树结构（一对多）图结构（多对多抽象数据类型不依赖具体实现与逻辑结构无关与物理结构无关与数据对象的操作无关与算法（如何使用操作）无关抽象数据类型就是定义了一个模版，使用前要对模版进行实现。
MySQL-数据结构（索引）选择的合理性
badBoy_badMan的博客
05-09 227
数据结构（索引）选择的合理性
CCF OJ 1113-括号匹配[栈]
06-09
这是一个栈的经典应用，可以通过栈来判断括号是否匹配。具体做法是遍历字符串，如果遇到左括号则入栈，如果遇到右括号，则判断栈顶元素是否为对应的左括号，如果是则出栈，否则返回false。最后判断栈是否为空，如果...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值