数据结构——栈和队列

最新推荐文章于 2024-09-11 11:13:16 发布
最新推荐文章于 2024-09-11 11:13:16 发布
阅读量1.2k 收藏 21
点赞数 21
分类专栏： 数据结构初阶 文章标签： 数据结构 开发语言 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CptGhost/article/details/142034477
版权

【本节内容】
 

1.栈


1.1栈的概念及结构


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

1.2栈的实现


栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
 

 

1.3栈的常见基本操作


STInit(ST* pst)：初始化一个空栈pst。
bool STEmpty(ST* pst)：判断一个栈是否为空，若栈为空则返回true，否则返回false。
STPush(ST* pst, STDataType x)：进栈(栈的插入操作)，若栈pst未满，则将x加入使之成为新栈顶。
STPop(ST* pst)：出栈（栈的删除操作），若栈pst非空，则弹出栈顶元素。
STDataType STTop(ST* pst)：读栈顶元素，若栈pst非空，则返回栈顶元素。
STDestroy(ST* pst)：栈销毁，并释放pst占用的存储空间。

STSize(ST* pst):计算栈的大小，返回栈顶元素的位置

代码实现：

Stack.h:

#pragma once
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

void STInit(ST* pst);
void STDestroy(ST* pst);
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
STDataType STTop(ST* pst);
bool STEmpty(ST* pst);
int STSize(ST* pst);

Stack.c：

#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	//pst->top = -1;   // top 指向栈顶数据
	pst->top = 0;   // top 指向栈顶数据的下一个位置
	pst->capacity = 0;
}

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

void STPush(ST* pst, STDataType x)
{
	if (pst->top == pst->capacity)
	{
		int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newCapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

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

STDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	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;
}

对于栈的各项功能，大家可以在主函数中自己进行测试，这边就不做过多的演示。

2.队列


2.1队列的概念及结构


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

2.2队列的实现


队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
 

2.3队列的常见基本操作

 

QueueInit(Queue* pq)：初始化队列，构造一个空队列pq。
QueueEmpty(Queue* pq)：判队列空，若队列pq为空返回true，否则返回false。
QueuePush(Queue* pq, QDataType x)：入队，若队列pq未满，将x加入，使之成为新的队尾。
QueuePop(Queue* pq)：出队，若队列pq非空，删除队头元素。

QueueFront(Queue* pq)：读队头元素，若队列pq非空，返回头部元素的数据。

QDataType QueueBack(Queue* pq)：读出队尾元素，若队列pq为非空，返回队尾元素数据。

QueueSize(Queue* pq)：计算队列大小，返回队列大小的值。

QueueDestroy(Queue* pq)：销毁队列，释放队列的空间。

Queue.h:

#pragma once
#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* phead;
	QNode* ptail;
	int size;
}Queue;

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

Queue.c:

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->phead = NULL;
	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, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail\n");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->ptail == NULL)
	{
		assert(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(!QueueEmpty(pq));
	// 1、一个节点
	// 2、多个节点
	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--;
}

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

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

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

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	/*return pq->phead == NULL && pq->ptail == NULL;*/
	return pq->size == 0;
}

3.经典题

选择题：

 

解答：

 

编程题:

1. 括号匹配问题.OJ链接:20. 有效的括号 - 力扣（LeetCode）

代码：

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* pst);
void STDestroy(ST* pst);
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
STDataType STTop(ST* pst);
bool STEmpty(ST* pst);
int STSize(ST* pst);
void STInit(ST* pst) 
{
    assert(pst);
    pst->a = NULL;
    pst->top = 0; // top指向栈顶的下一个位置
    pst->capacity = 0;
}
void STDestroyed(ST* pst) 
{
    assert(pst);
    free(pst->a);
    pst->a = NULL;
    pst->capacity = pst->top = 0;
}
void STPush(ST* pst, STDataType x) 
{
    if (pst->top == pst->capacity) 
    {
        int newCapacity = pst->capacity == 0 ? 4 : pst->capacity*2;
        STDataType* temp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
        if (temp == NULL) 
        {
            perror("relloc fail");
            return;
        }
        pst->a = temp;
        pst->capacity = newCapacity;
    }
    pst->a[pst->top] = x;
    pst->top++;
}
void STPop(ST* pst) 
{
    assert(pst);
    assert(!STEmpty(pst));
    pst->top--;
}
STDataType STTop(ST* pst) 
{
    assert(pst);
    assert(!STEmpty(pst));
    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;
}
bool isValid(char* s) 
{
    ST st;
    STInit(&st);
    while (*s) 
    {
        if (*s == '(' || *s == '[' || *s == '{') 
        {
            STPush(&st,*s);
        } 
        else 
        {
            if (STEmpty(&st)) 
            {
                STDestroyed(&st);
                return false;
            }
            char top = STTop(&st);
            STPop(&st);
            if ((*s == ')' && top != '(' )
            || (*s == ']' && top != '[')
            ||(*s == '}' && top != '{')) 
            {
                STDestroyed(&st);
                return false;
            }
        }
        s++;
    }
    bool ret = STEmpty(&st);
    STDestroyed(&st);
    return ret;
}

 

运行结果：

PS：看到这里了，码字不易，给个一键三连鼓励一下吧！有不足或者错误之处欢迎在评论区指出！   

 

Le-Code
关注
  • 21
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现的任意进制转换（数据结构——栈和队列）
08-10
本文将深入探讨如何使用C++语言实现任意进制转换，特别是涉及到小数部分的处理，并结合数据结构中的栈和队列进行阐述。C++作为一门强大的静态类型语言，其丰富的库支持和高效性能使得它成为实现这种算法的理想选择。...
数据结构——栈和队列（详解）
2302_80023639的博客
03-09 864
栈，一种仅允许在一端进，一端出的结构如上图所示，进数据和出数据的一端叫做栈顶，而相反的一段则叫做栈底数据从栈顶入，从栈顶出我们可以以吃货的视角打开栈：栈就像一个肉串，串肉要从尖的一段串进去，同时也是从尖的一端被吃掉我们还能发现，先被串进去的肉，会最后被吃掉栈也是如此，符合FILO原则，FILO就是 first in last out，翻译过来就是先进后出就像我们日常生活中的排队一样，队列就是从一端进，从另一端出。
数据结构——栈和队列详细解释
m0_61886762的博客
09-24 2524
你们在使用电脑中也会经历过机器有时会处于疑似死机的状态，鼠标点什么地方都没有任何反应，双击任何快捷键都不动弹。就当你失去内心时，机器突然对你刚的所有操作都执行了一遍。这是因为操作系统在当时可能CPU没有忙过来。操作系统中应用了一种数据结构来实现上述所说的问题也就是先进先出的功能，这就是队列。队列是一种先进先出的线性表简称FIFO。允许插入的操作为队尾，允许删除的操作为队头。就类似于最近几年的做核酸排队的操作，你在入队时是从队尾排队做核酸，做完之后是从队伍的头部做完后退出队伍。
14_L3缓存友好的数据结构
刘炫320的博客
09-11 475
老鸟：L3缓存是CPU缓存层次结构中的第三层，通常比L1和L2缓存大，但访问速度稍慢。L3缓存友好的数据结构设计旨在最大限度地减少缓存未命中，从而提升性能。菜鸟：那这些数据结构有什么特点呢？老鸟：主要特点是数据局部性好，也就是说，数据在内存中是连续存储的，这样能更好地利用缓存行。我们可以从一个简单的例子开始，比如数组和链表的对比。老鸟：总结一下，L3缓存友好的数据结构通过提升数据局部性来提高性能。常见的有数组、等。它们在大数据处理和高性能计算中非常有用。但在实际应用中，需要权衡性能、可维护性和具体需求。
【数据结构】——1.1树
qq_43507078的博客
09-07 1065
树，二叉树
C++笔记18•数据结构:AVL树•
qq_64446190的博客
09-06 464
AVL树
21_动态规划与数据结构结合
刘炫320的博客
09-11 401
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
哈希表的底层实现(1)---C++版
2301_80377335的博客
09-08 721
比如2.1中的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4， 因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。，首先对关键码集合用散列函数计算散列地址，具有相同地 址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链 接起来，各链表的头结点存储在哈希表中。//三个状态，这里定义了哈希表中的数据的多个状态，在红黑树的模拟实现中有用过，这样方便判断此位置的数据状态，方便以后的线性探测和删除数据等。
C语言基础——⑩③数据结构——②栈和队列
2401_82508270的博客
09-06 739
栈是一种逻辑结构，是特殊的线性表。
【数据结构】二叉树顺序存储结构堆的应用以及解决TOP-K问题
2301_80191662的博客
09-05 1016
二叉树顺序存储结构堆的应用以及解决TOP-K问题，堆排序
二叉树（上）
最新发布
xiaochuan_bsj的博客
09-11 775
主要介绍了树和二叉树的概念方面的大致内容，以及实现二叉树的创建和三种遍历方式。
数据结构--经典排序之选择排序（超详细！！）
2301_79381549的博客
09-04 796
它的工作原理是，首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。.如果在交换之前，max恰好是begin，那么由于begin位置的值已经被交换出去，我们需要更新max为min的位置。.接着，我们使用Swap函数将begin位置的值与最小值进行交换，这样确保了begin位置始终是已排序的最小值。.Swap 函数是一个简单的值交换函数，它接受两个整数的指针，并交换它们所指向的值。
C语言代码练习(第十八天)
2201_75306399的博客
09-09 992
C语言代码练习
【数据结构】希尔排序（缩小增量排序）
2301_79633555的博客
09-08 622
引入希尔排序的原因 思路分析 gap分组问题 代码实现 易错提醒 排序小tips
0基础跟德姆（dom）一起学AI Python进阶10-算法和数据结构
chrisfanallin的博客
09-11 817
AI全流程带你玩 0基础带你学人工智能相关软件，讲解机器学习、深度学习、大模型等人工智能领域核心知识。 帮助想了解，或者正在AI赛道成长的你。
数据结构(2):LinkedList和链表[1]
zh04101912138的博客
09-08 766
单链表的实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值