数据结构-栈和队列

最新推荐文章于 2024-08-06 21:51:46 发布
最新推荐文章于 2024-08-06 21:51:46 发布
阅读量196 收藏 1
点赞数
分类专栏： 数据结构（C语言实现） 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43570634/article/details/131805481
版权

栈和队列

栈

栈的基本概念

在这里插入图片描述

我们选用数组的形式来构成栈

栈的结构

以一个结构体的形式来表示栈的一些信息

typedef struct Stack
{
	STDataType* a;
	int top;//表示栈顶位置，也表示已存储的数据个数
	int capacity;//
}ST;

初始化栈

初始化结构体的各个成员，对指针所在位置开辟空间

void STInit(ST* ps)
{
	assert(ps);

	ps->a=(STDataType*)malloc(sizeof(STDataType)*4);
	if(ps->a==NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->top = 0;
	ps->capacity = 4;
}

销毁栈

对于malloc函数开辟的空间要释放掉，其它置0

void STDestroy(ST* ps)
{
	assert(ps);

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

压栈

空间不够，先开辟空间；给数据，然后top++

void STPush(ST* ps,STDataType x)
{
	assert(ps);

	if (ps->top==ps->capacity)
	{
		STDataType* temp=(STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (temp==NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = temp;
		ps->capacity = ps->capacity * 2;
	}

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

出栈

只需要动top的值即可，但是要确保栈中存在元素，用一个函数STEmpty来判断

bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top==0;
}
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

	ps->top--;
}

栈中元素的个数

直接返回top

int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

查找栈顶的元素

要先判断栈中是否含有元素，直接返回栈顶的元素（此处的top已经是++之后的，所以需要-1）

STDataType STTop(ST* ps)
{ 
	assert(ps);
	assert(!STEmpty(ps));

	return ps->a[ps->top-1];
}

压栈和出栈的一个演示

如下：

int main()
{
	ST plist;
	STInit(&plist);
	STPush(&plist, 1);
	STPush(&plist, 2);
	STPush(&plist, 3);
	STPop(&plist);
	STPush(&plist, 4);

	//打印方式，先返回栈顶的元素，再出栈
	while (!STEmpty(&plist))
	{
		printf("%d ", STTop(&plist));
		STPop(&plist);
	}

	STDestroy(&plist);
	return 0;
}

结果如下：
在这里插入图片描述

全部代码

Stack.h

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

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//表示栈顶位置，也表示已存储的数据个数
	int capacity;//
}ST;

void STInit(ST* ps);
void STDestroy(ST* ps);

//压栈
void STPush(ST* ps,STDataType x);
//出栈
void STPop(ST* ps);

bool STEmpty(ST* ps);

//栈中元素的个数
int STSize(ST* ps);

//查找栈顶的元素
STDataType STTop(ST* ps);

Stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"

void STInit(ST* ps)
{
	assert(ps);

	ps->a=(STDataType*)malloc(sizeof(STDataType)*4);
	if(ps->a==NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->top = 0;
	ps->capacity = 4;
}

void STDestroy(ST* ps)
{
	assert(ps);

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

void STPush(ST* ps,STDataType x)
{
	assert(ps);

	if (ps->top==ps->capacity)
	{
		STDataType* temp=(STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (temp==NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = temp;
		ps->capacity = ps->capacity * 2;
	}

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


bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top==0;
}
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

	ps->top--;
}

int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

STDataType STTop(ST* ps)
{ 
	assert(ps);
	assert(!STEmpty(ps));

	return ps->a[ps->top-1];
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "Stack.h"

int main()
{
	ST plist;
	STInit(&plist);
	STPush(&plist, 1);
	STPush(&plist, 2);
	STPush(&plist, 3);
	STPop(&plist);
	STPush(&plist, 4);

	//打印方式，先返回栈顶的元素，再出栈
	while (!STEmpty(&plist))
	{
		printf("%d ", STTop(&plist));
		STPop(&plist);
	}

	STDestroy(&plist);
	return 0;
}

队列

队列的基本概念

在这里插入图片描述

用单链表的方式来实现队列
基本组成元素为链表的单个节点，由于队列的性质，需要知道队头和队尾，同时我们还想知道队列中元素的个数
单个节点属于队列的局部，而队头和队尾属于队列，地位处于节点之上，这种情况下需要用结构体嵌套来表示

节点和队列的定义

//单个节点
typedef struct QueneNode
{
	struct QueneNode* next;
	QDataType data;
}QNode;

//整个队列
typedef struct Quene
{
	QNode* head;
	QNode* tail;
	int size;
}Quene;

队列的初始化

需要对pq进行断言，因为当pq所指向的空间为空时，其嵌套的结构体QNode将不存在，这不符合队列的要求。只对队列结构体初始化

void QueueInit(Quene* pq)
{
	assert(pq);

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

销毁队列

同销毁链表一致，同时head和tail置空，size置0

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

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

入队

申请一个新的节点，并对节点初始化，之后尾插

void QueuePush(Quene* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode==NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->next = NULL;
	newnode->data = x;

	//需要判断队列中是否有元素
	if (pq->head==NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

出队

要保证队列中有元素，之后头删

void QueuePop(Quene* pq)
{
	assert(pq);//确保有队列
	assert(pq->head != NULL);//确保队列不为空

	if (pq->head->next==NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}

计算队列中元素的个数

直接返回结构体中的size

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

	return pq->size;
}

判断队列是否为空

bool QueueEmpty(Quene* pq)
{
	assert(pq);

	return pq->size==0;
}

返回队列中的队头元素

要确保队列中有元素

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

	return pq->head->data;
}

返回队列中的队尾元素

要确保队列中有元素

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

	return pq->tail->data;
}

队列的一个演示过程

int main()
{
	Quene q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePop(&q);
	QueuePush(&q, 3);
	

	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}


	QueueDestroy(&q);
	return 0;
}

结果如下：
在这里插入图片描述

全部代码

Queue.h

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

typedef int QDataType;

//单个节点
typedef struct QueneNode
{
	struct QueneNode* next;
	QDataType data;
}QNode;

//整个队列
typedef struct Quene
{
	QNode* head;
	QNode* tail;
	int size;
}Quene;

//初始化
void QueueInit(Quene* pq);
//销毁
void QueueDestroy(Quene* pq);


//入队
void QueuePush(Quene* pq, QDataType x);
//出队
void QueuePop(Quene* pq);

//计算队列中元素的个数
int QueueSize(Quene* pq);
//判断队列是否为空
bool QueueEmpty(Quene* pq);

//队列中的队头元素
QDataType QueueFront(Quene* pq);
//队列中的队尾元素
QDataType QueueBack(Quene* pq);

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"

void QueueInit(Quene* pq)
{
	assert(pq);

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

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

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

void QueuePush(Quene* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode==NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->next = NULL;
	newnode->data = x;

	//需要判断队列中是否有元素
	if (pq->head==NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

void QueuePop(Quene* pq)
{
	assert(pq);//确保有队列
	assert(pq->head != NULL);//确保队列不为空

	if (pq->head->next==NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}

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

	return pq->size;
}

bool QueueEmpty(Quene* pq)
{
	assert(pq);

	return pq->size==0;
}

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

	return pq->head->data;
}

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

	return pq->tail->data;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "Queue.h"

int main()
{
	Quene q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePop(&q);
	QueuePush(&q, 3);
	

	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}


	QueueDestroy(&q);
	return 0;
}
登 风
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 - 栈和队列
qq_43629857的博客
06-22 6505
数据结构 - 栈和队列的定义和特点
数据结构-栈和队列+串-思维导图
学习记录
11-19 1089
数据结构-栈和队列+串-思维导图
数据结构-栈和队列-PPT
02-04
"数据结构-栈和队列-PPT" 数据结构中栈和队列是两种常用的线性表结构，下面对它们的定义、特点和应用进行详细介绍。 栈的定义和特点 栈是一种只能在一端（栈顶）进行插入和删除运算的线性表。栈的逻辑结构与...
数据结构-栈和队列的使用
03-25
栈和队列是两种基础且广泛使用的线性数据结构，它们在程序设计中扮演着重要角色。本篇将详细介绍这两种数据结构及其在C语言中的实现。 栈（Stack）是一种后进先出（Last In First Out, LIFO）的数据结构，类似于...
数据结构-栈和队列.pptx
07-11
数据结构中的栈和队列是两种非常基础且重要的线性数据结构，它们具有特定的插入和删除规则，分别遵循“后进先出”（LIFO）和“先进先出”（FIFO）的原则。 栈是一种只能在一端进行插入和删除的数据结构，通常称为...
数据结构-栈和队列.ppt
11-06
对线性表 L=(a1,a2,,...,an), 可在任意第i(i=1,2,,...n,n+1)个位置插入新元素， 或删除任意第i(i=1,2,,...n)个元素 受限数据结构---- 插入和删除受限制的线性表。 1.栈(stack), 2.队列(queue)
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64...
数据结构——顺序表
脑壳有点痒，好像要长脑子了！
08-03 955
顺序表是数据结构中的一种重要形式，它属于线性表的一种顺序存储结构，其逻辑上相邻的元素在物理存储位置上也相邻。用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。
数据结构（邓俊辉）学习笔记】词典 03—— 排解冲突(1)
最新发布
weixin_44399845的博客
08-06 488
学习下词条的排解冲突方法
数据结构 二叉树和堆总结
gma999的博客
07-31 1065
二叉树和堆的总结
【数据结构】堆的实现
t5y22的博客
08-03 576
堆
初识集合和数据结构
m0_51821434的博客
08-03 856
这次文章就浅浅的介绍了一下数据结构的基础知识，集合的框架，算法的一些特性
探索哈希表：C++中的实现与操作详解【Map、Set、数据结构】
qq_22841387的博客
08-03 774
哈希表（Hash Table）是一种常见的数据结构，它提供了一种高效的键值对存储方式，能够快速进行插入、删除和查找操作。在这篇博客中，我们将详细介绍哈希表的概念、在C++中的实现方式以及常见操作的示例。哈希表是一种通过哈希函数将键映射到存储桶（Bucket）或槽（Slot）中的数据结构。其核心思想是使用哈希函数将键转换为数组的索引，从而能够在常数时间内（平均情况下）进行查找、插入和删除操作。哈希表是一种高效的数据结构，广泛应用于需要快速查找、插入和删除操作的场景中。在C++中，提供了便捷的哈希表实现。
数据结构2:C++基于二叉堆实现优先队列
LorraineWen的博客
08-03 573
C++通过二叉堆实现优先队列
数据结构----------贪心算法
yuanbenshidiaos的博客
08-05 1755
贪心算法（Greedy Algorithm）是一种在问题求解过程中，每一步都采取当前状态下最优（即最有利）的选择，从而希望导致最终的全局最优解的算法策略。贪心算法的核心思想是做选择时，每一步只考虑当前情况的最佳选择，不考虑整体情况，也不考虑这个选择将如何影响未来的选择。局部最优选择：在每一步选择中都采取当前状态下最优的选择。不可回溯：一旦做出了选择，就不可撤销，也就是选择了某一部分的解之后，就不再考虑这个选择之前的其他可能性。最优子结构。
【数据结构之单链表的实现（不带头）】
2302_79546368的博客
08-03 779
与顺序表不同的是，链表里面的每节“车厢”都是独立申请下来的空间，所以我们之为“节/结点”。因此为了便于操作其它数据类型的操作，我们对类型进行重命名。假设当前链表中保存的是整型数据，当然我们也可以保存其它。保存下一个节点的地址（指针变量）当前节点要保存的数据。
"软件基础: 第四章 数据结构-栈和队列，第五章数据结构-栈、队列简介
在软件基础课程的第五章中，我们学习了数据结构中的栈和队列的概念和实现方法。本章主要包括了栈和队列的基本概念、顺序栈、链接栈、队列、顺序队列、环形队列和链接队列等内容。 在第四章中，我们首先介绍了数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值