【数据结构】栈和队列 （栈 栈的概念结构 栈的实现 队列 队列的概念及结构 队列的实现 栈和队列面试题）

已于 2023-03-09 17:12:58 修改
阅读量1.4k 收藏 5
点赞数 10
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 开发语言 leetcode c语言
于 2023-03-07 12:34:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68800221/article/details/129266220
版权

文章目录

前言

一、栈

1.1 栈的概念结构

栈也是一种线性表，数据在逻辑上挨着存储。只允许在固定的一端进行插入和删除元素。进行插入和删除操作的一端叫栈顶，另一端叫栈底。符合LIFO 先进后出。
在这里插入图片描述

压栈：插入操作。
出栈：删除操作。

1.2栈的实现

栈的实现用数组实现更好，因为完美符合数组的尾插尾删。
数组的缓存利用率高一点。
在这里插入图片描述
小练习：
在这里插入图片描述

支持动态增长的栈:

typedef int STDataType;
typedef struct Stack
{
 STDataType* _a;
 int _top; // 栈顶
 int _capacity; // 容量
}Stack;

初始化栈:

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

入栈:进栈（栈的插入操作），若栈未满，则将x加入使之成为新栈顶。

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}

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

出栈:出栈（栈的删除操作），若栈非空，则弹出栈顶元素，并用x返回。

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

销毁栈:栈销毁，并释放占用的存储空间

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

检测栈是否为空，如果为空返回非零结果，如果不为空返回0:

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}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);

Stack.c

#include "Stack.h"

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

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

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}

	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);
	return ps->top == 0;
}

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

二、队列

2.1队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾。
出队列：进行删除操作的一端称为队头。

2.2队列的实现

队列用链表的结构实现更优

在这里插入图片描述

链式结构：表示队列

typedef struct QListNode
{ 
 struct QListNode* _pNext; 
 QDataType _data; 
}QNode;

队列的结构：

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

初始化队列：

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

队尾入队列：

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;

	}

	if (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(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;

		free(del);
		del = NULL;

	}
	pq->size--;
}

获取队列头部元素：

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

获取队列队尾元素：

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

获取队列中有效元素个数：

int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

检测队列是否为空，如果为空返回非零结果，如果非空返回0：

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL && pq->tail == NULL;
}

销毁队列：

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;
		free(del);

	}
	pq->head = pq->tail = NULL;
}

Queue.h

#pragma once
#include <stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

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

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

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);

Queue.c

#include"Queue.h"

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* del = cur;
		cur = cur->next;
		free(del);

	}
	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;

	}

	if (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(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;

		free(del);
		del = NULL;

	}
	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL && pq->tail == NULL;
}

int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

三、栈和队列面试题

题目链接：
1.https://leetcode.cn/problems/valid-parentheses/
在这里插入图片描述

在这里插入图片描述

题目链接：
2.https://leetcode.cn/problems/implement-stack-using-queues/

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

总结

马尔科686
关注
  • 10
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
【数据结构】栈和队列
qq_43669007的博客
08-26 116
注意：栈和队列都是一种特殊的线性表 一.栈 先进后出（First In Last Out FILO） 后进先出（Last In First Out LIFO） 栈顶：top 栈底：bottom 栈顶指当前水平面的位置 操作： 1.初始化 2.压栈、弹栈 3.查找当前栈顶元素 4.判断为空 5.返回元素个数 push 放入数据 压栈 pop 删除数据 弹栈 实现： 链表...
【数据结构】栈和队列面试题总结(持续更新中...)
weixin_44258092的博客
08-09 658
介绍了栈和队列相关的OJ题目。
栈和队列经典面试题
bit_zyx的博客
04-07 3100
目录 1、括号匹配问题 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 1、括号匹配问题 链接直达： 有效的括号 题目： 思路： 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 ...
请你用数组来实现队列和栈（大厂经典面试题）
weixin_46838716的博客
04-29 689
将数组arr拿来实现队列了，关键就在size控制实际入的数，然后用pushi控制入的下标，polli控制弹出的下标。用数组arr实现栈，再简单不过了，一个pushi搞定压入弹出操作。
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
比特数据结构课件-Lesson4-栈和队列.pdf
07-07
在概念选择题中，了解栈和队列的性质是解题的关键： 1. 由于栈遵循LIFO原则，所以元素出栈的顺序应为EDCBA54321，对应选项B。 2. 进栈序列1,2,3,4，如果可以进栈过程中出栈，那么1肯定是最先出栈的，所以选项A是不...
【剑指offer】面试题9-用两个栈实现队列-完整的可执行代码（Java）
01-22
题目描述： 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 解题思路参考：https://blog.csdn.net/flower_48237/article/details/104055970
360架构师 分享 超详细大厂程序员高频面试题-如何用栈实现队列
09-20
360架构师 分享 超详细大厂程序员高频面试题-如何用栈实现队列 站台巨人肩膀上，弯道超车，秒杀面试官
（剑指offer）面试题09. 用两个栈实现队列
12-21
队列是一种基本的数据结构，遵循“先入先出”（First In First Out, FIFO）的原则，而栈则是“后进先出”（Last In First Out, LIFO）。在本题中，我们需要使用两个栈来模拟队列的行为。 题目要求我们实现一个类`C...
c语言（7.23）
fhgfyrsg的博客
07-23 580
【代码】c语言（7.23）
【算法与数据结构】并查集
2301_79728896的博客
07-23 338
合并和查询集合的数据结构，KruskalLCA查询的时间复杂度：小于O(log2​n)近乎O(1)
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 756
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 343
对于二分搜索的理论与实现的知识点学习。
数据结构：逻辑结构与物理结构
最新发布
Weiki的博客
07-24 957
数据结构：逻辑结构与物理结构
数据结构之深入理解简单选择排序：原理、实现与示例（C，C++）
qq_35320456的博客
07-24 788
简单选择排序虽然在大数据量下效率不高，但它易于理解和实现，是理解排序算法基本思想的良好起点。在实际应用中，如果数据量较小或者对排序稳定性要求不高，选择排序可以作为一种简单有效的选择。
【初阶数据结构】复杂度算法题篇
2301_79849925的博客
07-24 320
我们可以先将所有元素翻转，这样尾部的 kmodn 个元素就被移至数组头部，然后我们再翻转 [0,kmodn−1] 区间的元素和 [kmodn,n−1] 区间的元素即能得到最后的答案。该方法基于如下的事实：当我们将数组的元素向右移动 k 次后，尾部 kmodn 个元素会移动至数组头部，其余元素向后移动 kmodn 个位置。时间复杂度：O(n)空间复杂度：O(1)
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 434
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
算法 - 查找算法（顺序、折半、红黑树、AVL树、B+树、散列）
暴力扬
07-21 957
本文一共讲解了以下查找算法： 1. 顺序查找 2. 折半查找（二分查找） 3. 分块查找 4. 二叉排序树查找 5. 平衡二叉树（AVL树）查找 6. 红黑树查找 7. B树查找 8. B+树查找 9. 散列查找 每种查找算法都包括了其查找原理、实现步骤、代码实现思路、C语言代码以及代码解释。
"数据结构面试题：栈和队列特点、存储结构、链表优点
"很好的数据结构面试题"文档提供了一系列关于栈、队列和链表的问题，并附有答案。其中，问题1到3涉及栈和队列的特点和存储结构，问题4和5测试对栈的理解，问题6和7探讨链表的特点和优点，问题8和9关注单链表和循环...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

马尔科686

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

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

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

打赏作者

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

抵扣说明：

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

余额充值