【数据结构10】栈和队列的实现

已于 2022-09-26 20:16:20 修改
阅读量407 收藏 1
点赞数 1
分类专栏： 数据结构基础
于 2022-09-26 20:13:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67077469/article/details/127059320
版权

文章目录

栈

思路

栈特点：先入后出
想法：
1.用数组实现栈
2.入栈就往数组后面增加数据
3.出栈就把数组最后一个数据删除
细节：
1.当数组空间不够时需要增容
2.所以要创建capacity来记录当前空间大小
3.需要返回栈的数据个数，所以要创建top来记录栈的个数
4.出栈和返回栈顶数据时，栈不为空时才有效

栈的创建

typedef int STDateType;
typedef struct Stack
{
	STDateType* a;
	int capacity;
	int top;
}ST;

栈的初始化

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

入栈

void StackPush(ST* ps, STDateType x)
{
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDateType* pf = realloc(ps->a,sizeof(STDateType) * newcapacity);
		if (pf == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		ps->a = pf;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

每回数据入栈时都需判断栈是否已满

出栈

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

出栈时需注意栈不能为空

栈顶的数据

STDateType StackTop(ST* ps)
{
	assert(ps);
	assert(ps->top != 0);
	return ps->a[ps->top - 1];
}

返回栈顶数据时需注意栈不能为空

栈的数据个数

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

判空

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

栈的销毁

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

队列

思路

想法：
1.用链表实现栈
2.创建2个指针指向该链表，head和tail，一个指向表头，一个指向表尾
3.每当入列时就将要入列的数据的地址链接在tail后面
4.每当出列时，释放head当前空间，同时将head后一个节点的地址赋给head
细节：
1.入列时，当队列为空需要直接将新节点赋值给head和tail
2.出列时队列一定不能为空
3.返回对头和对尾数据时队列也一定不能为空

队列的创建

typedef int QDateType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDateType data;
}QueueNode;

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

队列的初始化

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

入列

void QueuePush(Queue* pq, QDateType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

注意在队列为空时，入列和不为空时入列有一定的差别

出列

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* cur = pq->head->next;
	free(pq->head);
	pq->head = cur;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}

注意出列时队列一定不能为空

对头数据

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

注意队列一定不能为空

对尾数据

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

注意队列一定不能为空

队列的数据个数

int QueueSize(Queue* pq)
{
	assert(pq);
	//assert(!QueueEmpty(pq));
	int count = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		count++;
		cur = cur->next;
	}
	return count;
}

判空

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

队列的销毁

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

完整代码

栈

test.c

#include "stack.h"
TestStack()
{
	ST s1;
	StackInit(&s1);
	StackPush(&s1, 1);
	StackPush(&s1, 2);
	StackPush(&s1, 3);
	StackPush(&s1, 4);
	StackPrin(&s1);

	StackPop(&s1);
	StackPop(&s1);
	StackPrin(&s1);

	printf("%d", StackTop(&s1));
	StackDestroy(&s1);
}
int main()
{
	TestStack();
	return 0;
}

stack.h

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

typedef int STDateType;
typedef struct Stack
{
	STDateType* a;
	int capacity;
	int top;
}ST;

void StackInit(ST* ps);
void StackPush(ST* ps,STDateType x);
void StackPop(ST* ps);
void StackDestroy(ST* ps);
STDateType StackTop(ST* ps);
int StackSize(ST* ps);
bool StackEmpty(ST* ps);
void StackPrin(ST* ps);

stack.c

#include "stack.h"
void StackInit(ST* ps)
{
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
void StackPush(ST* ps, STDateType x)
{
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDateType* pf = realloc(ps->a,sizeof(STDateType) * newcapacity);
		if (pf == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		ps->a = pf;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top != 0);
	ps->top--;
}
void StackPrin(ST* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->top; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = 0;
	ps->top = 0;
}
STDateType StackTop(ST* ps)
{
	assert(ps);
	assert(ps->top != 0);
	return ps->a[ps->top - 1];
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
bool StackEmpty(ST* ps)
{
	assert(ps);
	if (ps->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

队列

test.c

#include "Queue.h"
TestQueue()
{
	Queue st;
	QueueInit(&st);
	QueuePush(&st, 1);
	QueuePush(&st, 2);
	QueuePush(&st, 3);
	QueuePush(&st, 4);

	QueuePop(&st);
	QueuePop(&st);
	QueuePop(&st);
	//QueuePop(&st);
	//QueuePop(&st);

	int count = QueueSize(&st);
	printf("%d\n", count);

	int ret1 = QueueFront(&st);
	printf("%d\n", ret1);
	int ret2 = QueueBack(&st);
	printf("%d\n", ret2);


	QueueDestroy(&st);
}
int main()
{
	TestQueue();
	return 0;
}

Queue.h

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

typedef int QDateType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDateType data;
}QueueNode;

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

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

Queue.c

#include  "Queue.h"
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = NULL;
	pq->tail = NULL;
}
void QueuePush(Queue* pq, QDateType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* cur = pq->head->next;
	free(pq->head);
	pq->head = cur;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}
QDateType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}
QDateType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}
int QueueSize(Queue* pq)
{
	assert(pq);
	//assert(!QueueEmpty(pq));
	int count = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		count++;
		cur = cur->next;
	}
	return count;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}
(unstoppable)
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】11.循环队列的实现
weixin_46955173的博客
01-14 892
目录 一、循环列表相对于普通列表的不同 二、图解分析 1.初始状态 2.添加元素后 3.队列满时 4.队列空时 5.扩缩容的问题 三、代码及详细注解 一、循环列表相对于普通列表的不同 1.普通列表只是用线性表实现类实现的，只有一个索引下标 2.入队好说，直接在尾部添加即可 3.而出队的话，需要把第一个元素移出去，后面的依次往前移动。而循环列表就是要解决这个问题产生的哦 4.循环队列设置了两个索引下标front,rear 5.front头指针，rear尾指针，刚开始...
【数据结构】栈和队列
qq_43669007的博客
08-26 111
注意：栈和队列都是一种特殊的线性表 一.栈 先进后出（First In Last Out FILO） 后进先出（Last In First Out LIFO） 栈顶：top 栈底：bottom 栈顶指当前水平面的位置 操作： 1.初始化 2.压栈、弹栈 3.查找当前栈顶元素 4.判断为空 5.返回元素个数 push 放入数据 压栈 pop 删除数据 弹栈 实现： 链表...
C语言实现栈和队列
qq_49613557的博客
04-22 802
C语言实现栈和队列 目录栈队列栈和队列完整代码实现 栈 1.栈 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在顶。 1.2栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小
数据结构——链表实现栈和队列
weixin_47865239的博客
09-19 220
利用链表实现栈就必须了解栈的入栈和出栈的顺序：先进后出 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define TYPE int typedef struct Node { TYPE data; struct Node* next; }Node; typedef struct StackList { Node* top; size_t cnt; }StackList; // 创建
数据结构(栈和队列的链表方式实现)
库蒂尼奥的博客
07-26 289
栈：一种特殊的线性结构，删除与插入元素的一端为栈顶，另一端为栈底，栈中元素遵循先进后出LIFO(（Last In First Out)的原则. 栈的实现可以使用数组或者链表，我们今天主要使用链表实现，我们在前面已经谈了单链表的操作，关于栈和队列只不过是对链表加以限制，好了，我们直接开始。 一、链栈的定义和初始化 //结构定义 typedef int STData; typedef struct StackNode{ STData Data; struct StackNode *Next; }Stack
数据结构【六】- 链表实现栈和队列
sunshine77_的博客
10-10 343
一. 使用链表实现栈 1. 原理 需求：由于栈是一个后入先出的结构，它只对栈的一段操作。无论是增加元素，删除元素，查看元素，都在栈顶进行。所以对于链表来说，我们的在添加和删除链表头的时间复杂度是O(1)。所以我们这里将链表头作为栈顶。 解决： （1）利用我们在【数据结构【二】-栈】中的栈的接口，来使用链表实现栈 public interface Stack...
数据结构（5）：链表实现栈和队列
小蚯蚓的博客
12-15 340
一、链表实现栈 1.链表代码 https://blog.csdn.net/u010886217/article/details/85014250中链表LinkedVirtualHeadList实现类 2.链表实现栈的java代码 （1）stack接口 public interface stack&lt;E&gt; { int getSize(); //获得元素个数 bo...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
Python 实现数据结构中的的栈队列
09-19
栈和队列是两种基本且常用的数据结构，它们在Python中有着多种实现方式。本篇文章将详细探讨如何使用Python来实现这些数据结构。 首先，栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构，它遵循...
数据结构介绍栈和队列的区别
05-07
在数据结构中，栈和队列是最基础且重要的两种线性数据结构，它们在算法设计和程序实现中扮演着重要角色。下面将详细阐述栈和队列的基本概念、特性以及它们的区别。 栈（Stack）是一种后进先出（Last In First Out, ...
数据结构3栈和队列.pdf
01-14
数据结构中的栈和队列是两种非常基础且重要的线性数据结构，它们在计算机科学中有着广泛的应用。栈，被称为“后进先出”（LIFO）的数据结构，因为元素的添加（入栈，Push）和移除（出栈，Pop）只能在栈顶进行。栈的...
xxxxdfgfdgfdgd
07-14
xxxxdfgfdgfdgd
SQL语句基础教程.pdf
最新发布
07-14
SQL语句基础教程.pdf
站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用
07-14
站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断路器保护灵敏度校验整改及剩余电流监测试点应用站用交流系统断
亲测好用的Mac arm64版本的终端
07-14
亲测好用的Mac arm64版本的终端
mamba-ssm-1.1.3-cp310-cp310-win-amd64.whl
07-14
mamba_ssm-1.1.3 Windows 下whl 直接 pip install 安装这个whl即可，注意该安装包没有绕过 selective_scan_cuda，运行速度同Linux下类似
多项式逼近方法比较与分析实验报告
07-14
多项式逼近方法比较与分析实验报告
Scratch Scratch 是一款由麻省理工学院（MIT）设计开发的少儿编程工具 它具有以下显著特点： 可视化编程 采用图
07-14
Scratch Scratch 是一款由麻省理工学院（MIT）设计开发的少儿编程工具。 它具有以下显著特点： 可视化编程 采用图形化的积木块拼接方式来编写程序，无需输入复杂的代码，降低了编程的门槛，让初学者，尤其是儿童，能够轻松上手。 丰富的创意表达 提供了多种角色、背景和声音资源，孩子们可以通过编程让角色动起来、与用户互动，还能创作故事、游戏、动画等各种有趣的作品。 培养逻辑思维 在拼接积木块的过程中，孩子们需要思考程序的逻辑顺序，如顺序执行、条件判断、循环等，从而培养逻辑思维能力。 社区分享 Scratch 拥有活跃的在线社区，用户可以分享自己的作品，欣赏他人的创作，互相学习和交流。 以下是一个简单的 Scratch 项目示例，让一个角色在舞台上移动： 当点击绿旗开始时，角色会不断向前移动。 通过 Scratch，孩子们可以在轻松愉快的氛围中探索编程的奥秘，激发创造力和对计算机科学的兴趣。它被广泛应用于学校的信息技术课程和课外的编程启蒙教育。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值