数据结构之栈和队列

已于 2022-11-18 22:14:58 修改
阅读量571 收藏 2
点赞数 10
文章标签： 数据结构 c语言
于 2022-11-18 22:14:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64334842/article/details/127927800
版权

目录

1.栈的概念2、栈的实现

1、队列的概念2、队列的实现

今天介绍的是栈和队列。

先说栈吧。

1.栈的概念

栈也是线性表的一种，不过他较为特殊。他只能在一边进行数据的出入。也就是说晚进的数据先出去。进行数据进出的一端叫做栈顶，另一端叫做栈底。

数据进入叫做压栈，数据出去叫做出栈。

 

从图中可以看出，栈的数据进出遵循后进先出的规则。

2、栈的实现

栈的实现可以使用数组也可使用链表。在这里我们使用数组，因为栈的数据进出本质是尾插尾删，而用链表实现，尾插与尾删还得先找到尾，相对于数组较为复杂。所以在这里选择数组。

栈有分为静态栈与动态增长的栈。

静态栈

 

在实际中相对不实用，所以在这里实现可以动态增长的栈。

这次我们实现的接口有：栈的初始化，压栈，出栈，返回栈顶数据，返回栈中数据个数，检验栈是否为空，销毁栈。

结构体创建：

typedef int Datatype;
typedef struct StackList
{
	Datatype* arr;
	Datatype top;// 初始为0，表示栈顶位置下一个位置下标
	Datatype capacity;
}SL;

初始化：

void initialize(SL* slnum)
{
	assert(slnum);

	slnum->capacity = 0;
	slnum->top = 0;
	slnum->arr = NULL;
}

扩容：

void expand(SL* slnum)
{
	assert(slnum);

	if(slnum->capacity == slnum->top)
	{
		Datatype newcapacity = slnum->capacity = 0 ? 4 : slnum->capacity * 2;
		SL* tmp = (SL*)realloc(slnum->arr,sizeof(Datatype) * newcapacity);
		if(tmp == NULL)
		{
			perror("realloc false");
			exit(-1);
		}
		slnum->arr = tmp;
		slnum->capacity = newcapacity;
	}
}

压栈：

void stackint(SL* slnum,Datatype n)
{
	expand(slnum);
	slnum->arr[slnum->top] = n;
	slnum->top++;
}

出栈：

void stackout(SL* slnum)
{
	assert(slnum);

	assert(slnum->top > 0);
	slnum->top--;
}

栈中元素个数：

Datatype stacktop(SL* slnum)
{
	assert(slnum);
	assert(!stackempty);
	return slnum->top-1;
}

获取栈顶：

Datatype get_stacktop(SL* slnum)
{
	assert(slnum);

	assert(!stackempty);

	return slnum->arr[slnum->top - 1];
}

检验栈是否为空：

bool stackempty(SL* slnum)
{
	assert(slnum);

	if (slnum->top > 0)
	{
		return true;
	}
	else
		return false;
}

销毁栈：

void destroy(SL* slnum)
{
	assert(slnum);

	slnum->capacity = 0;
	slnum->top = 0;
	free(slnum->arr);
	slnum->arr = NULL;
}

栈的介绍就到这里，下面开始介绍队列。

1、队列的概念

队列是在一端插入数据在另一端删除数据的线性表。队列的数据删除规则为先进先出。队列在队尾插入，在对头删除。

 2、队列的实现

队列的实现也可以使用数组，也可以使用链表，又因为使用数组实现队列时删除数据需要挪动数据因此在这里我们使用链表来实现队列。

因为我们在实现队列时需要在队头出队，在队尾入队。所以我们可以再次封装一个结构体变量，里面放入一个head指针，一个tail指针。

typedef int Qdatatype;
typedef struct QueueNode
{
	Qdatatype n;
	struct QueueNode* next;
}QNode;
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

接口实现：

初始化：

void QInit(struct Queue* p)
{
	assert(p);
	p->head = NULL;
	p->tail = NULL;

	p->size = 0;

}

队尾入队列：

void Queueint(Queue* p,Qdatatype n)
{
	assert(p);

	QNode* tmp = (QNode*)malloc(sizeof(QNode));

	QNode* tmp = (QNode*)malloc(p, sizeof(QNode));

	if(tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	tmp->n = n;
	tmp->next = NULL;
	p->size++;
	if( p->tail == NULL)
	{
		p->head = p->tail = tmp;
	}
	else
	{
		p->tail->next = tmp;
		p->tail = p->tail->next;
	}
}

队头出队列：

void Queueout(Queue* p)
{
	assert(p);
	assert(!Queueempty(p));
	if(p->head->next == NULL)
	{
		free(p->head);
		p->head = p->tail = NULL;
	}
	else
	{
		QNode* tmphead = p->head;
		p->head = p->head->next;
		free(tmphead);
	}
	
	p->size--;

}

判断队列是否为空：

bool Queueempty(Queue* p)
{
	return p->head == NULL&&p->tail == NULL;
}

获取队头数据：

Qdatatype Gettop(Queue* p)
{
	assert(p);

	assert(!Queueempty(p));

	assert(!queueempty(p));

	printf("%d ", p->head->n);
}

获取队尾数据：

Qdatatype Gettail(Queue* p)
{
	assert(p);

	assert(!Queueempty(p));

	assert(!queueempty(p));

	printf("%d ", p->tail->n);
}

有效数据个数：

Qdatatype Count(Queue* p)
{
	return p->size;
}

销毁队列：

void destroy(Queue* p)
{
	assert(p);
	QNode* cur = p->head;
	while(cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	free(p->head);
	free(p->tail);


}

3、完整版代码

栈：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int Datatype;
typedef struct StackList
{
	Datatype* arr;
	Datatype top;// 初始为0，表示栈顶位置下一个位置下标
	Datatype capacity;
}SL;

//接口功能实现
//初始化
void initialize(SL* slnum);
//扩容
void expand(SL* slnum);
//入栈
void stackint(SL* slnum,Datatype n);
//出栈
void stackout(SL* slnum);
//获取栈有效元素个数
Datatype stacktop(SL* slnum);
//获取栈顶元素
Datatype get_stacktop(SL* slnum);
//检查栈是否为空
bool stackempty(SL* slnum);
//销毁
void destroy(SL* slnum);
#pragma once
#include"stacklist.h"
void initialize(SL* slnum)
{
	assert(slnum);

	slnum->capacity = 0;
	slnum->top = 0;
	slnum->arr = NULL;
}
void expand(SL* slnum)
{
	assert(slnum);

	if(slnum->capacity == slnum->top)
	{
		Datatype newcapacity = slnum->capacity = 0 ? 4 : slnum->capacity * 2;
		SL* tmp = (SL*)realloc(slnum->arr,sizeof(Datatype) * newcapacity);
		if(tmp == NULL)
		{
			perror("realloc false");
			exit(-1);
		}
		slnum->arr = tmp;
		slnum->capacity = newcapacity;
	}
}
void stackint(SL* slnum,Datatype n)
{
	expand(slnum);
	slnum->arr[slnum->top] = n;
	slnum->top++;
}
void stackout(SL* slnum)
{
	assert(slnum);

	assert(slnum->top > 0);
	slnum->top--;
}
Datatype stacktop(SL* slnum)
{
	assert(slnum);
	assert(!stackempty);
	return slnum->top-1;
}
Datatype get_stacktop(SL* slnum)
{
	assert(slnum);

	assert(!stackempty);

	return slnum->arr[slnum->top - 1];
}
bool stackempty(SL* slnum)
{
	assert(slnum);

	if (slnum->top > 0)
	{
		return true;
	}
	else
		return false;
}
void destroy(SL* slnum)
{
	assert(slnum);

	slnum->capacity = 0;
	slnum->top = 0;
	free(slnum->arr);
	slnum->arr = NULL;
}

队列：

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

typedef int Qdatatype;
typedef struct QueueNode
{
	Qdatatype n;
	struct QueueNode* next;
}QNode;
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

//初始化
void QInit(struct Queue* p);
// 队尾入队列
void Queueint(Queue* p, Qdatatype n);
// 队头出队列
void Queueout(Queue* p);
// 获取队列头部元素
Qdatatype Gettop(Queue* p);
// 获取队列队尾元素
Qdatatype Gettail(Queue* p);
// 获取队列中有效元素个数
Qdatatype Count(Queue* p);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool Queueempty(Queue* p);
// 销毁队列
void destroy(Queue* p);
#include"queue.h"
void QInit(struct Queue* p)
{
	assert(p);
	p->head = NULL;
	p->tail = NULL;
<<<<<<< HEAD
	p->size = 0;
=======
>>>>>>> 5b9085118240e85a5ef7699a109d637576c62395
}
void Queueint(Queue* p,Qdatatype n)
{
	assert(p);
<<<<<<< HEAD
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
=======
	QNode* tmp = (QNode*)malloc(p, sizeof(QNode));
>>>>>>> 5b9085118240e85a5ef7699a109d637576c62395
	if(tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	tmp->n = n;
	tmp->next = NULL;
	p->size++;
	if( p->tail == NULL)
	{
		p->head = p->tail = tmp;
	}
	else
	{
		p->tail->next = tmp;
		p->tail = p->tail->next;
	}
}
bool Queueempty(Queue* p)
{
	return p->head == NULL&&p->tail == NULL;
}
void Queueout(Queue* p)
{
	assert(p);
	assert(!Queueempty(p));
	if(p->head->next == NULL)
	{
		free(p->head);
		p->head = p->tail = NULL;
	}
	else
	{
		QNode* tmphead = p->head;
		p->head = p->head->next;
		free(tmphead);
	}
	
	p->size--;

}
Qdatatype Gettop(Queue* p)
{
	assert(p);
<<<<<<< HEAD
	assert(!Queueempty(p));
=======
	assert(!queueempty(p));
>>>>>>> 5b9085118240e85a5ef7699a109d637576c62395
	printf("%d ", p->head->n);
}
Qdatatype Gettail(Queue* p)
{
	assert(p);
<<<<<<< HEAD
	assert(!Queueempty(p));
=======
	assert(!queueempty(p));
>>>>>>> 5b9085118240e85a5ef7699a109d637576c62395
	printf("%d ", p->tail->n);
}
Qdatatype Count(Queue* p)
{
	return p->size;
}
void destroy(Queue* p)
{
	assert(p);
	QNode* cur = p->head;
	while(cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	free(p->head);
	free(p->tail);


}

俞定延
关注
数据结构：栈和队列
个人站点：javatv.net
07-12 338
之前参加过一次面试，上来就问我栈和队列。说实话，作为一个非科班出来的，并没有学过《数据结构》这门课，所以也就简单知道点什么先进先出，先进后出之类的，当我说完这个之后。 面试官那表情：就这？出门右转，简历要还给你吗？ 我：嘿嘿嘿，淦???? 写在前面 栈和队列，也属于线性表，因为它们也都用于存储逻辑关系为 “一对一” 的数据。使用栈结构存储数据，讲究先进后出，即最先进栈的数据，最后出栈；使用队列存储数据，讲究先进先出，即最先进队列的数据，也最先出队列。 什么是栈 栈是一种只能从表的一端存取数据且遵循 “先进后
数据结构--栈和队列
nifecat的博客
04-11 165
使用C语言封装栈和队列：struct node{ int value; node *pre, *next;};struct mystack{ node *head, *tail; int sz; void stack_init(){ head = tail = NULL; sz = 0; } void stack_push(int v){ if (sz == 0){ head = (no...
【数据结构】每天五分钟，快速入门数据结构（四）—— 栈和队列
最新发布
Liu_y_xin的博客
08-11 281
每天五分钟，快速入门数据结构之 栈和队列
【数据结构】栈和队列
See_Star的博客
09-14 172
栈（stack）：后进先出（last-in，fist-out，LIFO）。 队列（queue）：先进先出（first-in，first-out，FIFO）。 栈 栈上的INSERT操作称为PUSH（压入）；DELETE操作称为POP（弹出），为无元素参数操作。 类似于餐馆里装有弹簧的摞盘子的栈。盘子从栈中弹出的次序刚好同它们压入的次序相反，只有最上面的盘子才能被取下来。 队列 队列的INSERT操作称为ENQUEUE（入队）；DELETE操作称为DEQUEUE（出对），为无元素参数操作。 队列有队头（hea
数据结构之栈和队列 基本的增删查改
04-03
数据结构之栈和队列 基本的增删查改。栈（Stack）和队列（Queue）是数据结构中常用的两种基本数据结构。栈是一种后进先出（Last In First Out, LIFO）的数据结构，只允许在栈顶进行插入和删除操作；而队列是一种先进...
数据结构之栈和队列-思路清晰纯C
08-31
队列 循环队列 栈 内容学习于 https://www.bilibili.com/video/BV1W64y1z7jh?p=19&spm_id_from=pageDriver&vd_source=4d33bf4ac4499f2c0370694554a02fa5
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
python数据结构之栈和队列.md
06-25
python数据结构之栈和队列.md
数据结构之 栈和队列
ws - 兮的博客空间
05-27 827
一、栈 1、描叙 栈和队列是计算机中基本的两个数据结构，栈可以达到后进先出，队列可以先进先出。在实际应用上，我们可以使用栈进行逆序遍历链表，非递归中序遍历二叉树，括号匹配，函数调用等等；可以使用队列对二叉树进行层次遍历，打印机的打印服务，通信中的消息队列等等。 栈的储存规则: 1，栈只能从表的一端存取数据，另一端是封闭的 2，在栈中，无论是存数据还是取数据，都必须遵循"先进后出"的原则，即最先进栈的元素最后出栈。 栈的使用案例1: 浏览器 “回退” 功能的实现，底层使用的就是栈存储结构。 当你关闭页面 A
数据结构_栈和队列
cute_shuai的博客
02-24 189
栈栈的特点：遵循“先进后出，后进先出”原则； 队列的特点：遵循“先进先出，后进后出”原则
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值