【数据结构初阶】5. 栈和队列

最新推荐文章于 2024-08-28 17:35:17 发布
最新推荐文章于 2024-08-28 17:35:17 发布
阅读量325 收藏 1
点赞数 4
分类专栏： 数据结构初阶 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60915103/article/details/128044466
版权

栈

1.1 栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。**进行数据插入和删除操作的一端
称为栈顶，另一端称为栈底。**栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。
在这里插入图片描述
从栈顶进，从栈顶出

这里理解栈不能和操作系统当中的栈区混淆
在这里插入图片描述
堆区是用来动态规划的（通常都很大，以G为单位），而栈区的空间则比较小（以M为单位）
所以在递归的过程中很容易出现栈溢出的现象
在这里插入图片描述
但是操作系统中的栈和数据结构中的栈有相似的性质：
操作系统的栈区中函数栈帧的创建也是先创建的后销毁，变量也是如此
数据结构中的栈是创建在堆区上的(堆区空间大，动态内存开辟)

1.2 栈的实现情况

在这里插入图片描述
通常情况下采取数组的形式设计栈，只要记住尾部位置即可，而且空间也是连续的，符合栈的性质
但是如果为了节省空间，也可以采取链表的方式
在这里插入图片描述

1.3 栈的代码实现

gitee代码提交：栈的实现

01 栈的定义和声明

typedef int STDataType;

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

data–动态开辟的数组 capacity–容量 top–栈顶

02 栈的初始化

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

将ps->data 置NULL
ps->capacity 和 ps->top都置为0

03 销毁接口

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

将动态开辟的data释放，capacity和top置0 即可

04 推入接口 Push

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

栈因为其独特的性质，只能在栈顶插入元素，所以检查是否需要扩容也只需要在该模块进行（不需要再将其封装成CheckCapacity接口）
在ps->top的位置插入x，再让top++

05 弹出接口 Pop

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

再弹出栈顶元素之前需要断言栈是否为空，直接–top即可

06 判空接口 Empty

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

不需要采用 if / else 的方式直接return top是否等于0 （等于0 返回1 不等于0 返回0）

07 计算栈元素个数接口

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

当前top所在位置为栈顶元素的下一位，而返回个数正好是top

08 返回栈顶元素

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

09 测试上述接口

在这里插入图片描述

在实现栈的过程中，不难发现有些接口过于简单，那有必要再将其封装成接口的形式嘛，直接在Test中实现不也可行嘛？

数据结构建议不要直接访问结构数据，一定要通过函数接口访问，主要是为了实现解耦 – 低耦合 高内聚。
当我们的栈实现完成后，调用栈的使用者不必关心我们内部如何实现，只需要调用接口即可。

1.4 栈的运用

有效的括号
在这里插入图片描述
该题要实现的就是括号的匹配问题，将左符号放在栈中，拿右符号与栈顶的左符号对应，若不匹配返回false
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
到这里代码通过了，是不是就完成了呢？
NO！NO！NO！ 我们可以很明显的发现只有最后的return flag 之前对栈进行了销毁StackDestroy 。
而其他return 返回值，并没有释放使用的栈空间，就会导致内存泄漏的问题。
虽然该问题很容易忽视，但当大项目出现内存泄漏的时候排查起来会非常困难，所以在平时要养成习惯：在开辟空间后要及时释放
在每个return前加上StackDestroy(&st);即可

队列

2.1 队列的概念及结构

在这里插入图片描述
在这里插入图片描述

2.2 队列的实现情况

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些。
因为如果使用数组的结构，出队列在数组头上出数据，就要进行挪动数据，将后面的数据往前挪 ，时间复杂度：O(N)

2.3 队列的代码实现

gitee仓库：队列的实现

01 队列的定义与声明

typedef int QDataType;

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

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

队列结点QNode
队列结构体Queue包含 结点指针head指向队头，结点指针tail指向队尾，size计算队列长度
两层结构体
将队列单独封装成结构体的好处，接口可以不需要使用到二级指针QNode** ，只需要使用Queue* 改变其中的内容即可
(如果不封装结构体，修改QNode* head 和QNode* tail 所指向内容需要使用二级指针QNode**)

02 初始化队列

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

03 销毁接口

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

队列是通过链表的形式实现的，从head结点开始遍历即可

04 插入接口 Push

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

队列的特性：只能在队尾插入数据
创建newnode 链接进队列，
若队列为空 newnode 为队头/队尾
若队列不为空 newnode 链接到tail 之后，成为新的队尾

05 弹出接口 Pop

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

队列的特性：只能从队头弹出数据
在弹出前，先断言队列是否为空，如果队列中只有一个元素，弹出后将head和tail置NULL
如果队列中还存在其他元素，找到下一结点，使之成为新结点

06 返回队头数据

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}

07 返回队尾数据

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

在返回数据前先判断队列是否为空

08 判断是否为空

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

09 队列长度

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

10 测试上述接口

void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	QueuePush(&q, 5);
	QueuePush(&q, 6);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	printf("\n当前队列长度：%d\n", QueueSize(&q));
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");
	QueueDestroy(&q);
}
int main()
{
	TestQueue();
	return 0;
}

队列和栈的出数据顺序

队列的出数据顺序只有一种，因为队列只能从队头弹出数据，即使数据存放在队列中，队列最终的出数据顺序还是只存在顺序的情况。
而栈只能从队尾弹出数据，所以可以在推入后立马弹出，也可以选择存放在栈中，所以栈的出数据顺序可以多种多样。

栈和队列的OJ题

1. 用队列实现栈

在这里插入图片描述
在这里插入图片描述

具体代码实现：

// ...
// 前面部分为队列的实现代码
// 将两个队列封装在结构体当中 该结构体为匿名结构体
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    // 创建双队列结构体
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    //对结构体中的双队列进行初始化
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x) {
    //在其中一个队列中插入数据即可
    //q1 非空 插q1
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    //空 插q2
    else
    {
        QueuePush(&obj->q2,x);
    }
}

// 弹出并返回栈顶元素
int myStackPop(MyStack* obj) {
    //假设q1为空 q2为非空
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }
    while(QueueSize(nonempty) > 1)
    {
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }
    int top = QueueBack(nonempty);
    QueuePop(nonempty);
    return top;
}

int myStackTop(MyStack* obj) {
    //假设q1为空 q2为非空
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }
    return QueueBack(nonempty);
}

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

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);
}

在代码实现过程中出现的问题：
在这里插入图片描述

2. 用栈实现队列

在这里插入图片描述

在这里插入图片描述

// ...
// 前面代码部分为栈的实现代码
typedef struct {
    ST pushST;
    ST popST; 
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->pushST);
    StackInit(&obj->popST);
    return obj;
}

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

void PushSTToPopST(ST* PushST,ST* PopST)
{
    while(!StackEmpty(PushST))
    {
        StackPush(PopST,StackTop(PushST));
        StackPop(PushST);
    }
}
int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->popST))
    {
        PushSTToPopST(&obj->pushST,&obj->popST);
    }
    int tmp = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return tmp;
}

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popST))
    {
        PushSTToPopST(&obj->pushST,&obj->popST);
    }
    return StackTop(&obj->popST);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->popST) && StackEmpty(&obj->pushST);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->popST);
    StackDestroy(&obj->pushST);
    free(obj);
}

3. 设计循环队列

在这里插入图片描述
在这里插入图片描述
逻辑结构：循环队列 物理结构：采用数组的方式存储（也可以用链表，虽然循环链表更符合逻辑结构，但是链表初始化链接…相对麻烦）

typedef struct {
    int N; // N个空间 
    int* a; // a数组
    int back;// 队尾的下一位
    int front;// 队头
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    // 结构体判空
    if (obj == NULL)
    {
        perror("MyCircularQueue malloc fail");
        exit(-1);
    }
    // 数组长度设计为k+1
    obj->a = (int*)malloc((k + 1) * sizeof(int));
    // 数组判空
    if (obj->a == NULL)
    {
        perror("arror malloc fail");
        exit(-1);
    }
    obj->back = obj->front = 0;
    //数组长度
    obj->N = k + 1;
    return obj;
}

在这里插入图片描述

哈茶真的c
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
如何用栈结构实现队列结构
Harrison的学习博客
11-26 315
如何用栈结构实现队列结构：用两个栈拼队列结构 package com.harrison.class02; import java.util.Stack; public class Code07_TwoStacksImplementQueue { public static class TwoStacksToQueue{ public Stack<Integer> pushStack; public Stack<Integer> popStack; public
【数据结构】栈与队列
Dooo_yh的博客
01-10 929
解决栈与队列90%的问题
【C++内存管理】第一篇:（malloc/deldete和malloc/free）
qq_53505979的博客
06-19 769
目录一级目录 一级目录
C语言-8月1日-递归与动态内存管理
曾铎的博客
08-02 2234
递归所产生的代价大，而函数执行所需的空间是在栈区进行开辟的（.stack），Windows的默认栈区大小是1M，所以递归也是危险的，如果在没有手动对计算机栈区空间进行扩充的前提下，使用递归实现一个所需区域极其大的功能，有可能会让程序崩溃。从斐波那契序列中我们可以看出，要通过递归的方式解决问题时，我们首先要做的就是分析问题，摸清楚问题的规律，将一个大的问题分解为小的问题，例如斐波那契序列我们直接把它分解为从第一个数开始，摸清楚规律后分解问题，问题规模不断缩小，最后再通过反方向将问题合并，最终解决问题。....
【初阶数据结构】5.栈和队列
hlyd520的博客
07-20 1637
一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。实际中还有一种特殊的队列叫循环队列，环形队列首尾相连成环，环形队列可以使用数组实现，也可以使用循环链表实现。
《数据结构初阶》之栈和队列
m0_60756071的博客
02-25 181
栈功能实现部分 #define _CRT_SECURE_NO_WARNINGS 1 #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
数据结构初阶--栈和队列
weixin_67916525的博客
03-15 225
栈栈的概念及结构栈：一种特殊的线性表，其只允许在固定的一端插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO (Last In First Out) 的原则；同时对于栈来说，一种入栈顺序对应多种出栈顺序。
数据结构初阶：栈和队列
yourfriendyo的博客
11-05 841
文章目录栈和队列1 栈1.1 栈的定义和结构栈结构体定义1.2 栈的实现栈初始化和销毁栈的压入和弹出获取栈顶元素其他基本接口2 队列2.1 队列的定义和结构队列结构体定义2.2 队列的实现队列初始化和销毁队尾入队和队头出队获取队头队尾元素其他基本接口3 栈和队列面试题Example 1 有效括号Example 2 队列实现栈Example 3 栈实现队列Example 4 循环队列 栈和队列 栈和队列都是数据结构的一种，本章利用线性表来模拟实现栈和队列这两种结构。 1 栈 1.1 栈的定义和结构 栈是一
数据结构初阶（栈和队列）
wuweixiaoyue的博客
04-27 510
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。出栈：栈的删除操作叫做出栈。出数据在栈顶。JVM虚拟机栈 VS 栈JVM虚拟机栈：系统的一块内存栈：数据结构队列。
【数据结构初阶】：栈和队列的实现（用C语言实现，附图详解和附源码）
平凡的指针的博客
11-01 1232
文章目录栈的实现：一、栈的概念和性质二、栈的实现思路三、栈的相关变量内存布局图四、栈的初始化和销毁五、栈的接口实现：1.入栈2.出栈3.获取栈顶的数据4.获取栈的元素个数5.判断栈是否为空队列的实现：一、队列的概念和性质二、队列的实现思路三、队列相关变量的内存布局图四、队列的初始化和销毁五、队列的接口实现：1. 入数据2.出数据3.取队头数据4.取队尾数据5.获取队列元素个数6.判断队列是否为空总结 栈的实现： 一、栈的概念和性质 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在固定的一端进行插
数据结构初阶数据结构初阶
02-12
初学者在学习数据结构时，通常会遇到一系列基础概念和重要类型，这些都会在"数据结构初阶"的学习中逐步揭示。 首先，我们要理解数据结构的基本概念。数据结构是存储和组织数据的一种方式，它不仅考虑了数据的存储，...
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
基础的数据结构通常包括数组、链表、栈、队列、树和图等。这些结构各有特点，适用于不同的场景： 1. **数组**：是最基本的数据结构，提供了通过索引访问元素的能力。在C和C++中，数组是连续存储的数据集合，但大小...
C语言实现数据结构算法初阶算法
06-15
5. **队列**：队列是一种先进先出（FIFO）的数据结构，适用于任务调度和消息传递。C语言中，队列可由数组（循环队列）或链表实现，常用的操作有enqueue（入队）和dequeue（出队）。 6. **二叉树遍历**：二叉树是一...
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
m0_62171658的博客
03-29 4099
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
数据结构之LRUCache
我要学编程的博客
08-22 1132
LRU Cache 的概念、模拟实现、相关练习
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1223
数据结构-时间、空间复杂度-详解
排序------快速排序（C语言实现）
markingyi的博客
08-25 863
讲解快速排序原理，并通过例题使用C语言实现。
八股总结-----C++、数据结构、算法
m0_48022770的博客
08-25 369
存储可执行代码（程序指令）。：存储全局变量和静态变量（已初始化和未初始化）。：用于动态内存分配，由程序员管理。：存储函数调用中的局部数据（局部变量、参数、返回地址）。
Linux 数据结构 链表
最新发布
mxyzhy的博客
08-28 257
单向链表操作
Sun云计算技术：数据仓库DW初阶与云基础
在数据仓库（DW）初阶阶段，我们关注的是如何构建和利用数据仓库来支持企业的决策制定。数据仓库是一个专门设计用于数据分析的系统，它整合了来自不同业务系统的数据，提供了单一的视图，以便进行报告、分析和挖掘。...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值