栈和队列的应用

最新推荐文章于 2023-05-16 17:42:18 发布
最新推荐文章于 2023-05-16 17:42:18 发布
阅读量78 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 算法 leetcode 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69356256/article/details/128405404
版权

目录

1.括号匹配问题

  给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：(1)左括号必须用相同类型的右括号闭合。(2)左括号必须以正确的顺序闭合。(3)每个右括号都有一个对应的相同类型的左括号。
来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/valid-parentheses/

1.1流程图

栈的括号匹配

1.2代码

//使用动态数组实现栈
typedef struct SeqStack
{
    char* arr;
    int top;
    int capacity;
}SeqStack;

//判空
bool IsEmpty(SeqStack* ps)
{
    if(ps->top == -1)
        return true;

    return false;
}

//初始化
void InitStack(SeqStack* ps)
{
    ps->arr = (char*)malloc(4*sizeof(char));
    if(ps->arr == NULL)
        return;
    ps->top = -1;
    ps->capacity = 4;
}

//进栈
void Push(SeqStack* ps,char ch)
{
    if(ps->top + 1 == ps->capacity)
    {
        char* tmp = (char*)realloc(ps->arr,ps->capacity*2*sizeof(char));
        if(tmp == NULL)
            return;

        ps->arr = tmp;
        ps->capacity *= 2;
    }
    ps->arr[++ps->top] = ch;
}

//出栈
void Pop(SeqStack* ps)
{
    if(ps->top == -1)
        return;

    ps->top--;
}

//取栈顶元素
char GetTopElement(SeqStack* ps)
{
    char ch = ps->arr[ps->top];
    return ch;
}

//栈的括号匹配
bool isValid(char * s){
    int len = strlen(s);

    SeqStack stack;
    InitStack(&stack);
	
	//遍历原数组
    for(int i = 0;i < len;i++)
    {
    	//左括号进栈
        if(s[i] == '(' || s[i] == '[' || s[i] == '{')
        {
            Push(&stack,s[i]);
        }
        //右括号与栈顶元素比较
        else
        {
        	//右括号单身
            if(IsEmpty(&stack))
                return false;
			
			//取栈顶元素
            char ret = GetTopElement(&stack);
            //三种情况左右括号不匹配
            if(s[i] == ')' && ret != '(')
                return false;
            else if(s[i] == ']' && ret != '[')
                return false;
            else if(s[i] == '}' && ret != '{')
                return false;
            Pop(&stack);
        }
    }
	
	//左括号不单身
    if(IsEmpty(&stack))
        return true;
    //左括号单身
    else
        return false;
}

1.3复杂度

时间复杂度:O(n)
空间复杂度:O(1)

2.用队列实现栈

  请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/implement-stack-using-queues/

2.1思路

1.用两个队列实现栈的各个功能
2.创建栈
先创建栈malloc 再初始化两个队列
3.插入(push)
将数据插入到非空队列
4.删除(pop)
将非空队列(元素个数>1)倒到另外一个空队列当中，然后非空队列只剩一个元素，此时弹出该元素，就实现栈的删除
5.取栈顶元素
取非空队列的队尾元素
6.判空
当两个队列全为空时，栈为空
7.销毁栈(destroy)
先销毁两个队列，再释放栈

2.2画图

内存结构图

2.3代码

//方便修改数据类型
typedef int ElemType;

//定义队列结点
typedef struct QueueNode
{
	ElemType data;//数据域
	struct QueueNode* next;//指针域
}QueueNode;

//封装队头指针和队尾指针
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
	int size;
}Queue;

//初始化
void InitQueue(Queue* q)
{
	assert(q);

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

//判空
bool IsEmpty(Queue* q)
{
	assert(q);

	if (q->size == 0)
		return true;

	return false;
}

//入队
void Push(Queue* q,ElemType x)
{
	assert(q);

	if (q->size == 0)
	{
		QueueNode* tmp = (QueueNode*)malloc(sizeof(QueueNode));
		if (tmp == NULL)
			return;

		q->head = q->tail = tmp;
		tmp->data = x;
		tmp->next = NULL;
		q->size++;
	}
	else
	{
		QueueNode* tmp = (QueueNode*)malloc(sizeof(QueueNode));
		if (tmp == NULL)
			return;

		tmp->data = x;
		tmp->next = NULL;
		q->tail->next = tmp;
		q->tail = q->tail->next;
		q->size++;
	}
}

//出队
void Pop(Queue* q)
{
	assert(q && q->head);

	if (q->size == 0)
		return;

	if (q->head == q->tail)
	{
		free(q->head);
		q->head = q->tail = NULL;
		q->size--;
	}
	else
	{
		QueueNode* del = q->head;
		q->head = del->next;
		q->size--;
		free(del);
	}
}

//取队首元素
ElemType GetHeadElement(Queue* q)
{
	assert(q);
    assert(!IsEmpty(q));

	return q->head->data;
}

//取队尾元素
ElemType GetTailElement(Queue* q)
{
	assert(q && q->head);

	return q->tail->data;
}

//求队长
int QueueSize(Queue* q)
{
	assert(q);

	return q->size;
}

//销毁队列
void DestroyQueue(Queue* q)
{
	assert(q);
    

	QueueNode* cur = q->head;
	while (cur)
	{
		QueueNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
	q->head = q->tail = NULL;
	q->size = 0;
}

//封装两个队列定义栈结构
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

//先malloc在初始化两个队列
MyStack* myStackCreate() {
	//定义栈
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    
    //初始化队列q1和队列q2
    InitQueue(&obj->q1);
    InitQueue(&obj->q2);
	
	//返回栈
    return obj;
}

//进栈
void myStackPush(MyStack* obj, int x) {
	//在非空队列中插入数据
    if(!IsEmpty(&obj->q1))
        Push(&obj->q1,x);
    else
        Push(&obj->q2,x);
}

//出栈
int myStackPop(MyStack* obj) {
    //假设法找空队列
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;
    if(!IsEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }

	//当非空队列的元素个数>1,将其前面的元素插入到空队列当中实现倒数据
    while(QueueSize(nonempty) > 1)
    {
    	//往空队列中倒入一个元素,非空队列就删除该元素
        Push(empty,GetHeadElement(nonempty));
        Pop(nonempty);
    }
	
	//将非空队列的最后一个元素保存下来
    int top = GetHeadElement(nonempty);
    //删除非空队列的最后一个元素
    Pop(nonempty);
	
	//返回栈顶元素(非空队列的最后一个元素)
    return top;
}

//取栈顶元素
int myStackTop(MyStack* obj) {
	//将非空队列的队尾元素返回
    if(!IsEmpty(&obj->q1))
        return GetTailElement(&obj->q1);
    else
        return GetTailElement(&obj->q2);
}

//判空
bool myStackEmpty(MyStack* obj) {
	//当两个队列同时为空,栈就为空
    return IsEmpty(&obj->q1) && IsEmpty(&obj->q2);
}

//销毁栈
void myStackFree(MyStack* obj) {
	//销毁队列q1和队列q2
    DestroyQueue(&obj->q1);
    DestroyQueue(&obj->q2);

	//释放栈
    free(obj);
}

3.用栈实现队列

  请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）
来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/implement-queue-using-stacks/

3.1思想

1.用两个栈实现队列的各个功能
一个栈(pushStack)专门用来存数据，另外一个栈(popStack)用来删数据
2.创建队列
先创建队列malloc 再初始化两个栈
3.插入(push)
直接将元素插入到pushStack，也就是代码里的q1
4.取队首元素
将pushStack里的元素倒入到popStack中，然后再返回popStack的栈顶元素，并弹出该元素
5.删除(pop)
弹出popStack的栈顶元素
6.判空
当两个栈全为空，队列为空
7.销毁队列(destroy)
先销毁两个栈，再释放队列

3.2画图

两个栈实现队列

3.3代码

//方便修改数据类型
typedef int ElemType;

//定义栈结构
typedef struct SeqStack
{
	ElemType* a;
	int top;//栈顶指针
	int capacity;//栈容量
}SeqStack;

//判空
bool IsEmpty(SeqStack* ps)
{
	//为什么assert,非常规思维
	assert(ps);

	if (ps->top == -1)
		return true;

	return false;
}

//初始化
void InitStack(SeqStack* ps)
{
	assert(ps);

	ps->a = (ElemType*)malloc(4 * sizeof(ElemType));
	if (ps->a == NULL)
	{
	
		return;
	}
	ps->top = -1;
	ps->capacity = 4;
}

//取栈顶元素
ElemType GetTopElement(SeqStack* ps)
{
	assert(ps);

	ElemType x = ps->a[ps->top];

	return x;
}

//求栈长
int StackLength(SeqStack* ps)
{
	assert(ps);

	return ps->top + 1;
}

//进栈
void StackPush(SeqStack* ps, ElemType x)
{
	assert(ps);

	if (StackLength(ps) == ps->capacity)
	{
		ElemType* tmp = (ElemType*)realloc(ps->a, ps->capacity * 2 * sizeof(ElemType));
		if (tmp == NULL)
		{

			return;
		}

		ps->a = tmp;
		ps->capacity *= 2;
	}

	ps->a[++ps->top] = x;
}

//出栈
void StackPop(SeqStack* ps)
{
	assert(ps);

	if (IsEmpty(ps))
		return;

	ps->top--;
}

//销毁栈
void DestroyStack(SeqStack* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = -1;
}

//定义两个栈创建队列
typedef struct {
    SeqStack q1;
    SeqStack q2;
} MyQueue;

//创建队列再初始化两个栈
MyQueue* myQueueCreate() {
	//创建队列
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));

	//初始化两个栈
    InitStack(&obj->q1);
    InitStack(&obj->q2);

	//返回队列
    return obj;
}

//入队
void myQueuePush(MyQueue* obj, int x) {
    assert(obj);

    StackPush(&obj->q1,x);
}

//出队
int myQueuePop(MyQueue* obj) {
    assert(obj);
    
    int peek = myQueuePeek(obj);
    StackPop(&obj->q2);

    return peek;
}

//取队首元素
int myQueuePeek(MyQueue* obj) {
    assert(obj);
    
    //如果popStack为空且pushStack不为空
    //就将pushStack的元素倒入到popStack当中
    if(IsEmpty(&obj->q2))
    {
        while(!IsEmpty(&obj->q1))
        {
        	//将pushStack当中的元素倒入到popStack当中
            StackPush(&obj->q2,GetTopElement(&obj->q1));
            //弹出pushStack的栈顶元素
            StackPop(&obj->q1);
        }
    }
	
	//返回队首元素(也就是popStack当中的栈顶元素)
    return GetTopElement(&obj->q2);
}

//判空
bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
	
	//当两个栈同时为空时,队列为空
    return IsEmpty(&obj->q1) && IsEmpty(&obj->q2);
}

//销毁队列
void myQueueFree(MyQueue* obj) {
    assert(obj);

	//先销毁两个栈
    DestroyStack(&obj->q1);
    DestroyStack(&obj->q2);

	//释放队列
    free(obj);
}

4.循环队列

  设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-circular-queue

4.1思想

  使用链表或者数组实现循环队列，因为前者不能随机访问，所以我们选择用数组实现循环队列。循环队列头尾相连，大小固定。
两大问题:
1.如何判空判满
(1)增加加一个计数变量(size)
(2)创建一个空结点
2.如何用数组实现循环
(1)特殊处理
if(rear == Maxsize) rear = 0;
(2)循环取模
(rear + 1) % Maxsize

4.2画图

结构内存示意图
循环队列

4.3代码

//定义循环队列结构
typedef struct {
    int* arr;//数组
    int front;//队头指针
    int rear;//队尾指针
    int k;//循环队列有效元素个数
} MyCircularQueue;

//创建循环队列(队列总大小为k+1)
MyCircularQueue* myCircularQueueCreate(int k) {
	//创建循环队列
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));

	//开辟k+1个数组元素
    obj->arr = (int*)malloc((k+1)*sizeof(int));
    //置空
    obj->front = obj->rear = 0;
    //循环队列有效元素个数
    obj->k = k;

	//返回循环队列
    return obj;
}

//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);

    if(obj->front == obj->rear)
        return true;
    
    return false;
}

//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    assert(obj);

    if((obj->rear + 1)%(obj->k + 1) == obj->front)
        return true;
    
    return false;
}

//入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);
	//判满
    if(myCircularQueueIsFull(obj))
        return false;
	//存值
    obj->arr[obj->rear] = value;
    //循环
    obj->rear = (obj->rear + 1) % (obj->k + 1);

    return true;
}

//出队
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
	//判空
    if(myCircularQueueIsEmpty(obj))
        return false;
	//循环
    obj->front = (obj->front + 1) % (obj->k + 1);

    return true;
}

//取队首元素
int myCircularQueueFront(MyCircularQueue* obj) {
    assert(obj);
	//判空
    if(myCircularQueueIsEmpty(obj))
        return -1;
	//取值
    return obj->arr[obj->front];
}

//取队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    assert(obj);

	//判空
    if(myCircularQueueIsEmpty(obj))
        return -1;
	//找到rear的前一个结点
    int rear = (obj->rear + obj->k) % (obj->k + 1);
    return obj->arr[rear];
}

//销毁循环队列
void myCircularQueueFree(MyCircularQueue* obj) {
    assert(obj);
	//先释放开辟的k+1个数组大小的空间
    free(obj->arr);
	//再释放开辟的结构体变量
    free(obj);
}
www_wsxy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈和队列应用-钟球问题
03-22
球钟是一个利用球的移动来记录时间的简单装置 它有三个可以容纳若干个球的指示器：分钟指示器，五分钟指示器，小时指示器 若分钟指示器中有2个球，五分钟指示器中有6个球，小时指示器中有5个球，则时间为5:32 ...
堆栈队列应用
m0_46335449的博客
12-01 780
继续加油
数据结构之队列和栈的应用
AAS48的博客
11-01 1368
本文介绍队列和栈的实际应用：括号匹配、表达式求值 一、括号匹配问题 【问题描述】：给定一个仅含有括号的字符串，如何去判断该括号序列是否合法呢？ 例如：()()合法，(())合法，【()】合法 但((()不合法，【)【)不合法 用栈来解决。 下面开始模拟算法，走两遍 比如第一种情况：【()】【】 参考上面的算法思想，执行过程： 1、先看第一个括号，因为是左括号，所以直接把第一个括号【，压入栈中。 2、再看第二个，也是左括号(，所以直接扔进栈就行 3、第三个括号是右括号)，所以我们要弹出一个栈顶元素 (
【数据结构】栈和队列的实现及应用
学了就忘是正常现象
08-18 3271
栈和队列
栈和队列的相关功能实现及其基础应用
Lee贤的博客
05-16 1199
本文主要讲解了栈和队列的功能实现以及其相关的基础应用
【数据结构与算法】之栈与队列的应用和操作
╰つ栺尖篴夢ゞ
07-22 1056
栈 概念 栈：限定仅在表尾进行插入和删除操作的线性表，允许插入和删除的一端为栈顶，另一端是栈底。 性质：栈是一种LIFO(Last In First Out)的线性表，也就是数据元素遵循后进先出的原则。 栈的抽象数据类型： ADT 栈(Stack) Data 具有线性表一样的性质。 Operation top：获取栈顶元素 count：栈的长度 isEmpty：栈内元素是否为空 push(data)：元素进栈 pop()：元素出栈
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
栈和队列应用2制作糖果.py
04-28
栈和队列应用2制作糖果.py
数据结构之栈和队列应用PPT学习教案.pptx
10-05
数据结构之栈和队列应用PPT学习教案.pptx
栈和队列的基本操作及其应用
04-15
1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。 2、掌握栈和队列的特点，即后进先出和先进先出的原则。 3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序存储结构和链式存储结构上的实现。
栈和队列的一个应用
09-22
栈和队列的一个应用 这是用栈和队列模拟的一个停车场管理系统。进来一辆车登记后进入车场，如车场满则进来的车进入便道等候，一旦有车开走则便道自动进入车场。 用一个栈模拟停车场，用一个队列模拟车场外的便道。
栈与队列的应用与区别
04-19
栈与队列的应用与区别
栈和队列的操作和应用
sinat_58088248的博客
02-14 4097
本节内容 、 1.栈和队列的特性 栈：后进先出 •栈：受限制的线性表，只允许从表的一端操作。这端称为栈顶，另一端为栈底 •压入元素（push）：往栈顶新增一个元素，新元素成为新栈顶。 •弹出元素（pop）：移除栈顶元素，原栈顶的元素成为新栈顶/或栈变成空栈 •图片表示进出栈结果： *key1：栈是一种先进后出的数据结构，pop和push操作仅在栈顶进行 队列：先进先出 •队列：受限制的线性表，只允许从表的两端操作，一端是队首，一端是队尾。 •入队（enqueue）...
栈和队列的基本应用
CYBCLOUD的博客
08-27 2319
1 栈的基本应用 1.1括号匹配 问题: 假设表达式有三种括号：圆括号“（）”，花括号“｛｝”，方括号“［］”。它们可互相嵌套，如｛（［］）｝或｛（［］）（）［］｝均为正确格式。而｛）），｛［（）］均为不正确格式。 输入由三种括号构成的字符串，如何检测字符串里括号格式的正确性？ 算法思路： 创建一个空栈，开始顺序扫描所有字符 遇到左括号入栈 遇到右括号则弹出已入栈的栈顶左括号（若栈为空没有左括号，直接退出报错） 检查两括号是否匹配（若两括号类型不一样，直接退出报错） 若所有字符都扫描完.
栈和队列的应用大全
weixin_46503238的博客
05-22 1719
应用一:栈在括号匹配中的应用 #include <stdio.h> #include <stdlib.h> #include<stdbool.h> #define MaxSize 50 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int top; } SqStack; bool InitStack(SqStack *s) { s->top=-1;//初
栈和队列及应用
m0_52559870的博客
02-27 1909
栈和队列 栈：限定仅在栈顶进行插入和删除操作的线性表 队列：只允许在一端进行插入操作，而在另一端进行删除操作的线性表 一、栈 1.栈的定义 栈（stack）：限定仅在栈顶进行插入和删除操作的线性表 允许插入和删除的一端称为栈顶（top），另一端称为栈底，不含任何数据元素的栈叫空栈 栈又被称为：后进先出的线性表，简称LIFO结构 栈的插入操作：进栈，压栈，入栈 栈的删除操作：出栈，弹栈 使用：如果栈的使用过程中元素变化不可预料，有时很大，有时很小，一般会用链式栈。 如果元素变化在可控
数据结构第三章——栈和队列的应用
cwb296的博客
05-22 1878
栈和队列的应用、斐波拉契数列，中缀表达式级
讲解栈和队列的设置与应用
最新发布
05-28
栈和队列是两种常见的数据结构，它们都是线性结构，可以用于许多实际的应用场景。 首先，我们来讲解一下栈。栈是一种后进先出（Last In First Out，LIFO）的数据结构，它的主要操作包括入栈和出栈。入栈指将元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值