数据结构——栈与队列的专题

最新推荐文章于 2024-05-23 22:32:15 发布
最新推荐文章于 2024-05-23 22:32:15 发布
阅读量468 收藏 12
点赞数 14
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79998744/article/details/138758022
版权

文章目录

前言

本篇是围绕栈与队列来展开，需要知道一定有关它们的相关基础知识

栈的详解
队列的详解

还有一道基础的栈题——有效的括号

一、用队列实现栈

原题链接：用队列实现栈

在这里插入图片描述

解题思路：
首先创建一个队列结构

然后用两个队列去实现一个栈，每次始终保持一个队列为空

入栈操作相当于给非空队列进行入队操作
出栈操作相当于非空队列的队尾元素出队，此时需要把非空队列除最后一个元素之外的其余元素入队到空队列，然后出队最后一个队尾元素

在这里插入图片描述

在这里插入图片描述

//实现队列
typedef int QDateType;
typedef struct QueueNode
{
	QDateType val;
	struct QueueNode* next;
}QNode;

//管理队列的结构体
typedef struct Queue
{
	QNode* phead;//指向队头的指针
	QNode* ptail;//指向队尾的指针
	int size;//队列数据个数
}Queue;

//队列的初始化
void QueueInit(Queue* pq);
//队列的销毁
void QueueDestroy(Queue* pq);

//队尾插入数据
void QueuePush(Queue* pq, QDateType x);
//队头删除数据
void QueuePop(Queue* pq);

//取出队尾的数据
QDateType QueueBack(Queue* pq);
//取出队头的数据
QDateType QueueFront(Queue* pq);

//取出队列数据个数
int QueueSize(Queue* pq);

//判断置空
bool QueueEmpty(Queue* pq);


//队列的初始化
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 = pq->ptail = NULL;
	pq->size = 0;
}


//队尾插入数据
void QueuePush(Queue* pq, QDateType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->val = x;
	newnode->next = NULL;

	//没有结点时，头插
	if (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(pq->phead);
	//只有一个结点
	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--;
}

//取出队尾的数据
QDateType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

//取出队头的数据
QDateType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->val;
}

//取出队列数据个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

//判断置空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}


typedef struct
{
    Queue p1;
    Queue p2;
} MyStack;


MyStack* myStackCreate()
{
    //开辟一个模拟栈
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    //将队列初始化
    QueueInit(&(pst->p1));
    QueueInit(&(pst->p2));
    return pst;
}

void myStackPush(MyStack* obj, int x)
{
    //将数据插入非空队列
    if(!QueueEmpty(&(obj->p1)))
    {
        QueuePush(&(obj->p1), x);
    }
    else
    {
        QueuePush(&(obj->p2), x);
    }
}

int myStackPop(MyStack* obj)
{
    //假设法
    Queue* empty = &(obj->p1);
    Queue* nonempty = &(obj->p2);
    if(!QueueEmpty(&(obj->p1)))
    {
       empty = &(obj->p2);
       nonempty = &(obj->p1);
    }
    //将size-1个数据移动到空队列
    while(QueueSize(nonempty) > 1)
    {
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }
    //保存最后一个数据
    int top = QueueFront(nonempty);
    QueuePop(nonempty);
    return top;
}

int myStackTop(MyStack* obj)
{
    if(!QueueEmpty(&(obj->p1)))
    {
        return QueueBack(&(obj->p1));
    }
    else
    {
        return QueueBack(&(obj->p2));
    }
}

bool myStackEmpty(MyStack* obj)
{
    return QueueEmpty(&(obj->p1)) && QueueEmpty(&(obj->p2));
}

void myStackFree(MyStack* obj)
{
    //将队列销毁
    QueueDestroy(&(obj->p1));
    QueueDestroy(&(obj->p2));
    //将模拟栈销毁
    free(obj);
}

二、用栈实现队列

原题链接：用栈实现队列
在这里插入图片描述

解题思路：

此题可以用两个栈实现，一个栈进行入队操作，另一个栈进行出队操作

出队操作： 当出队的栈不为空时，直接进行出栈操作，如果为空，需要把入队的栈元素全部导入到出队的栈，然后再进行出栈操作

在这里插入图片描述

//实现动态增长的栈
typedef int STDateType;
typedef struct Stack
{
	STDateType* a;
	int top;//栈顶
	int capacity;//容量
}ST;

//初始化和销毁
void STInit(ST* pst);
void STDestroy(ST* pst);

//入栈和出栈
void STPush(ST* pst, STDateType x);
void STPop(ST* pst);

//取栈顶数据
STDateType STTop(ST* pst);

//判空
bool STEmpty(ST* pst);

//获得数据的个数
int STSize(ST* pst);

//初始化和销毁
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	//top指向栈顶数据的下一个元素
	pst->top = 0;

	//top指向栈顶元素
	//pst->top = -1;

	pst->capacity = 0;
}

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

//入栈和出栈
void STPush(ST* pst, STDateType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		//扩容
		int newcapacity = pst->capacity == 0 ? 4 : 2 * pst->capacity;
		STDateType* tmp = realloc(pst->a, newcapacity * sizeof(ST));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top++] = x;
}

void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}

//取栈顶数据
STDateType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}

//判空
bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

//获得数据的个数
int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}



typedef struct
{
    ST pushst;//专门插入数据的
    ST popst;//专门出数据的
} MyQueue;


MyQueue* myQueueCreate()
{
    //开辟一个模拟队列
    MyQueue* pst = (MyQueue*)malloc(sizeof(MyQueue));
    //初始化栈
    STInit(&(pst->pushst));
    STInit(&(pst->popst));
    return pst;
}

void myQueuePush(MyQueue* obj, int x)
{
    //默认插入第一个栈
    STPush(&(obj->pushst),x);
}
int myQueuePeek(MyQueue* obj);
int myQueuePop(MyQueue* obj)
{
    //调用peek函数
    int top = myQueuePeek(obj);
    //删除栈顶元素
    STPop(&(obj->popst));
    return top;
}

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);
}

三、设计循环队列

原题链接：设计循环队列

在这里插入图片描述

解题思路：

通过一个定长数组实现循环队列

入队：首先要判断队列是否已满，再进行入队的操作，入队操作需要考虑索引循环的问题，当索引越界，需要让它变成最小值
出队：首先要判断队列是否为空，再进行出队操作，出队也需要考虑索引循环的问题

判空： 队头 = 队尾
判满： 队尾 + 1 = 队头

在这里插入图片描述

typedef struct
{
    int* a;//动态数组储存数据
    int head;//指向队头
    int tail;//指向队列尾数据的下一个位置
    int k;//队列长度    
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k)
{
    //开辟一个循环队列
    MyCircularQueue* pst = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //创建一个可以存放k个元素的循环队列，实际申请的空间为k + 1
    pst->a = (int*)malloc((k + 1) * sizeof(int));
    pst->head = 0;
    pst->tail = 0;
    pst->k = k;
    return pst;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
    return obj->head == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj)
{
    return (obj->tail + 1) % (obj->k + 1) == obj->head;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    //注意回绕问题
    obj->a[obj->tail++] = value;
    obj->tail %= obj->k + 1;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    //注意回绕问题
    obj->head++;
    obj->head %= obj->k + 1;
    return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj)
{
     if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[(obj->tail - 1 + obj->k + 1 )% (obj->k + 1)];
}

void myCircularQueueFree(MyCircularQueue* obj)
{
    free(obj->a);
    free(obj);    
}
郭二哈
关注
  • 14
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
数据结构期末通关——栈与队列PPT
08-16
bilibili账号642257246，视频教程配套课件
数据结构——栈和队列（详解）
2302_80023639的博客
03-09 757
栈，一种仅允许在一端进，一端出的结构如上图所示，进数据和出数据的一端叫做栈顶，而相反的一段则叫做栈底数据从栈顶入，从栈顶出我们可以以吃货的视角打开栈：栈就像一个肉串，串肉要从尖的一段串进去，同时也是从尖的一端被吃掉我们还能发现，先被串进去的肉，会最后被吃掉栈也是如此，符合FILO原则，FILO就是 first in last out，翻译过来就是先进后出就像我们日常生活中的排队一样，队列就是从一端进，从另一端出。
数据结构——栈和队列
一只向入研坑的程序猿
04-25 207
数据结构——栈和队列
数据结构专题——栈与队列之顺序栈及其Java实现
Jesmin的CSDN博客
11-01 310
在前面的几章博客中，我与同学们一起熟悉了线性表这个基础的数据结构，今天我们要学习的这个数据结构和线性表有着紧密的联系，它就是——栈。栈的定义很简单：栈(Stack)是限定仅在表尾进行插入和删除操作的线性表。我们一起来解读一下栈的定义，首先栈是一个线性表，因此它也是一个具有零个或多个数据元素的有限序列；其次栈只允许在表的尾部进行插入和删除元素，而不像是普通的线性表能够在任意位置添加删除元素。
数据结构专题——栈与队列之链栈及其Java实现
Jesmin的CSDN博客
11-01 321
在上一篇博客中，博主与大家学习了一个新的数据结构——栈。它是一个只被允许在栈顶进行插入与删除元素的特殊线性表，是一种典型的LIFO的数据结构。在我们用数组的方式实现了顺序存储的顺序栈之后，本章博客中我们就一起来尝试实现一个链式存储的栈吧。和普通的线性表一样，我们可以选择用单链或者是双链来实现这个数据结构。由于栈只能够在栈顶进行入栈和出栈操作，因此一个只含有栈顶节点的单链表就可以轻松实现它了。
数据结构专题——栈与队列之栈的应用(一)
Jesmin的CSDN博客
11-04 411
在自己实现了内存中顺序存储和链式存储的栈结构之后，有的同学可能还是有一些疑问。既然都是线性表，我们为什么不直接使用顺序表或链表，反而要创造出一种特殊的线性表呢？其实答案很简单，通过我们规定了特殊规则之后的线性表，能够更轻松地完成很多工作。
数据结构专题（ 二）——栈与队列
wzcspace
02-05 370
什么是栈？ 其实栈就是一种后进先出的结构，就像一沓书本，每次取书本只能从最上面取，那么压在最底下的书本肯定是最先摆放在桌面上的，自然而然肯定是最后被取走的。 什么是队列？ 队列是一种先进先出的结构，队列在生活中的例子就更多了，火车站排队，食堂买盒饭的队伍，其实都可以抽象成一个队列，每当一个人买完票或者拿到盒饭就会离开队列，先来到售票或者食堂窗口的人肯定是先买到票或者吃饭的。 数据结构其实充...
C/C++数据结构——队列
敲代码嘞~的博客
10-24 762
在前面学习了栈的基本知识，知道栈是一种特殊的线性表，其特点是先进后出。而接下来要学的队列也是一种操作受限的线性表，其特点是先进先出。从队头出队，从队尾入队。
leetcode专题训练——栈和队列
zyc12321的博客
03-11 95
1、155. 最小栈 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。 pop()—— 删除栈顶的元素。 top()—— 获取栈顶元素。 getMin() —— 检索栈中的最小元素。 解答：两个栈，一个维护最小值 2、150. 逆波兰表达式求值 根据 逆波兰表示法，求表达式的值。 有效的运算符包括+,-,*,/。每个运算对象可以是整数，也可以是另一个逆波兰表达式。 解答：栈的经典应用 ...
数据结构——顺序表专题
weixin_52550678的博客
02-15 1107
数据结构是由“数据”和“结构”两词组合而来的。数据：常见的数值、网页中肉眼可见的信息，这些都是数据。结构：当我们想要使用大量同一类型的数据时，通过手动定义大量的独立的遍历对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将大量的数据组织在一起，结构也可以理解为组织数据的方式。数据结构是计算机存储、组织数据的方式。数据结构是指相互之间在一种或多种特定关系的数据元素的集合。数据结构反映数据的内部构成，即数据由那部分构成，以什么方式构成，以及数据元素之间呈现的结构。
数据结构第三章笔记——栈和队列
10-21
数据结构第三章笔记——栈和队列
C++实现的任意进制转换（数据结构——栈和队列）
08-10
C++语言实现带小数的任意进制转换，使用了数据结构中的栈和队列，在VC++6.0上编译运行通过。对于学习C++和数据结构有一定的参考意义！
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64...
数据结构——栈与队列
11-23
不错的课件，很详细。计算机的基础，希望对你有用
C-数据结构-单向循环链表
aqiangdeba的博客
05-23 281
单向无头结点一定要注意传参 一般是二维指针问题 非常容易出错。
初阶数据结构—栈和队列
Awkwardx的博客
05-23 1010
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。压栈：栈的插入操作叫做进栈/压栈/入栈，。出栈：栈的删除操作叫做出栈。。
数据结构（二）单链表
最新发布
weixin_44254079的博客
05-23 1268
数据结构 单链表实现
【数据结构】第一章：绪论
小源同学的博客
05-23 730
一般来说,用计算机解决一个具体问题时,大致需要经过下列几个步骤:首先要从具体问题抽象出一个适当的数学模型,然后设计一个解此数学模型的算法,最后编出程序进行测试、调整直至得到最终解答。寻求数学模型的实质是分析问题,从中提取操作的对象,并找出这些操作对象之间含有的关系,然后用数学的语言加以描述。例如,求解梁架结构中应力的数学模型为线性方程组;预报人口增长情况的数学模型为微分方程。然而更多的非数值计算问题无法用数学方程加以描述。例1图书馆的书目检索系统自动化问题例2 计算机和人对弈问题。
python数据结构栈与队列
04-27
栈（stack）和队列（queue）都是常见的数据结构，它们可以用来解决很多实际问题。 栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构，类似于一个垂直的栈，只能在顶部进行插入和删除元素的操作。栈的主要应用有：括号匹配、表达式求值、深度优先搜索等。 在Python中，可以使用列表（list）来模拟栈的操作，例如： ```python stack = [] stack.append(1) # 入栈 stack.append(2) stack.append(3) print(stack) # [1, 2, 3] stack.pop() # 出栈 print(stack) # [1, 2] ``` 队列是一种先进先出（First-In-First-Out，FIFO）的数据结构，类似于排队等待服务的场景。队列的主要应用有：广度优先搜索、计算机任务调度等。 在Python中，可以使用collections模块中的deque来模拟队列的操作，例如： ```python from collections import deque queue = deque() queue.append(1) # 入队 queue.append(2) queue.append(3) print(queue) # deque([1, 2, 3]) queue.popleft() # 出队 print(queue) # deque([2, 3]) ``` 需要注意的是，如果需要同时在列表的头尾进行添加和删除操作，可以考虑使用双向队列（deque）来代替列表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值