【数据结构】栈&队列

最新推荐文章于 2026-01-02 22:40:17 发布
原创 最新推荐文章于 2026-01-02 22:40:17 发布 · 165 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

文章详细介绍了如何使用数组和链表分别模拟实现栈和队列这两种基本数据结构，包括它们的初始化、销毁、压栈/入队、出栈/出队、判空、取栈顶/队首和队尾元素等操作。栈采用数组实现，支持FILO（先进后出）操作，而队列使用链表实现，遵循FIFO（先进先出）原则。

目录

一、Stack——栈

1.1栈

1.2栈的模拟实现

1.2.1栈的创建

1.2.2栈的初始化&销毁

1.2.3压栈&出栈

1.2.4判空&取栈顶&栈的大小

1.3完整代码

二、Queue——队列

2.1队列

2.2队列模拟实现

2.2.1队列的创建

2.2.2队列的初始化&销毁

2.2.3入队列&出队列

2.2.4大小&判空&队首&队尾

2.3完整代码

一、Stack——栈

1.1栈

栈（stack）是一种线性的数据储存结构，它支持先进后出的操作方式，即First In Last Out（FILO）。

 

栈支持的基本操作有初始化、判空、压栈（push）、出栈（pop）、读取栈顶元素以及销毁等方式。

1.2栈的模拟实现

1.2.1栈的创建

和链表一样，栈也是用结构体来实现的，但是使用链式结构还是顺序表呢？如果用链的话，每次出栈都需要找到尾结点的前一个，会造成许多不必要的麻烦，当然双向链表可以解决这个问题，但是仔细想想，似乎用数组来的更方便一些。

 数组本身就更容易在尾部进行操作，我们把数据依次压入数组中，再从数组尾部输出，这不就是FILO吗？

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;  //数组模拟实现
	int top;        //top为栈顶元素指向的下一个位置
	int capcacity;  //capacity表示栈的大小
}ST;

1.2.2栈的初始化&销毁

初始化一个栈，也就是要我们先开辟一块数组的空间，同时初始化栈顶元素并按大小设置capacity。而销毁一个栈也就是要释放这块数组的空间并置为空，同时将栈顶和大小回到0。

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->capcacity = 4;
}

void STDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capcacity = 0;
}

1.2.3压栈&出栈

由于栈是由数组模拟实现的，入栈和出栈其实也就是对数组进行插入删除，但要特别注意的是，top指向的是栈顶元素的下一个位置。

void STPush(ST* ps, STDataType x)
{
	assert(ps);
    //先判断是否需要扩容
	if (ps->capcacity == ps->top)//满栈时top与数组大小相同
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capcacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capcacity *= 2;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

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

1.2.4判空&取栈顶&栈的大小

这个很简单，我们已经在结构体里设置了top元素，因此栈的大小可以由top得出，而top是否为0也决定的栈是否为空。

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

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

STDataType STTop(ST* ps)
{
	assert(ps);
	return ps->a[ps->top-1];
}

1.3完整代码

//Stack.h

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

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;  //数组模拟实现
	int top;        //top为栈顶元素指向的下一个位置
	int capcacity;
}ST;

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

//Stack.c

#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->capcacity = 4;
}

void STDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capcacity = 0;
}

void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->capcacity == ps->top)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capcacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capcacity *= 2;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

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

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

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

STDataType STTop(ST* ps)
{
	assert(ps);
	return ps->a[ps->top-1];
}

二、Queue——队列

2.1队列

队列与栈相似，也是一种线性的数据储存结构。只不过队列支持的是先进先出操作方式，即First In First Out（FIFO）。

 队列支持的操作与栈相同，但是由于队列的结构不同，队列还支持取尾元素。

2.2队列模拟实现

2.2.1队列的创建

队列与栈的逻辑结构是相似的，那是否我们也可以像栈那样使用数组来实现队列呢？队列与栈不一样的地方在于队列支持的是FIFO操作，因此我们要不断变化队首的元素，如此一来，用数组实现的话，每次操作都会调动整个数组，严重影响效率，但是链表可以支持头插头删，这样一来，FIFO的问题便可迎刃而解。

typedef int QDataType;
//嵌套结构体
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

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

2.2.2队列的初始化&销毁

由于队列是由链表实现的，而链表的操作在上一篇博客中有所讲解，因此在这便不做过多介绍

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

void QueueDestroy(Queue* 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;
}

2.2.3入队列&出队列

void QueuePush(Queue* pq, QDataType x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode -> next = NULL;
	if (pq->head == NULL)
	{
		assert(pq->tail == NULL);//是否为空
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;//换尾
	}
	pq->size++;
}

void QueuePop(Queue* 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--;
}

2.2.4大小&判空&队首&队尾

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

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

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

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

2.3完整代码

//Queue.h

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

typedef int QDataType;
//嵌套结构体
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

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

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

#include "Queue.h"

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

void QueueDestroy(Queue* 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(Queue* pq, QDataType x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode -> next = NULL;
	if (pq->head == NULL)
	{
		assert(pq->tail == NULL);//是否为空
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;//换尾
	}
	pq->size++;
}

void QueuePop(Queue* 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(Queue* pq)
{
	assert(pq);
	return pq->size;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

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

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

那么最后我们再来简单测试一下栈和队列的代码。

//Test.c

#include "Stack.h"
#include "Queue.h"

void TestStack()
{
	ST stack;
	STInit(&stack);
	STPush(&stack, 1);
	STPush(&stack, 2);
	STPush(&stack, 3);
	STPush(&stack, 4);
	STPush(&stack, 5);
	STPush(&stack, 6);
	STPush(&stack, 7);
	printf("Top: %d \n", STTop(&stack));
	printf("Size: %d \n", STSize(&stack));
	STPop(&stack);
	STPop(&stack);

	printf("Top: %d \n", STTop(&stack));
	printf("Size: %d \n", STSize(&stack));
}

void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePush(&q, 6);
	QueuePush(&q, 7);
	printf("Front: %d \n", QueueFront(&q));
	printf("Back: %d \n", QueueBack(&q));
	printf("SIZE: %d \n", QueueSize(&q));
	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	printf("Front: %d \n", QueueFront(&q));
	printf("Back: %d \n", QueueBack(&q));
	printf("SIZE: %d \n", QueueSize(&q));

}

int main()
{
	printf("Stack:\n");
	TestStack();
	printf("\n");
	printf("Queue:\n");
	TestQueue();
	return 0;
}

运行结果如下：

 

栈和队列的实现到此结束，接下来会更新栈和队列的一些应用、函数栈帧的创建与销毁、堆、二叉树、八大排序。

越努力，越幸运，加油！

数据结构：栈和队列(Stack & Queue)【详解】
UniqueUnit的博客
02-19 30万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&amp;S)：初始化一个空栈S。 StackEmpty(S)：
数据结构---栈&&队列
2301_80097874的博客
05-31 937
栈和队列是我们数据结构中经常使用的数据结构，所以现在来了解一下栈和队列。
【数据结构】栈和队列
小羊的博客
07-12 3661
栈超超超详解
数据结构——栈和队列
2302_80250536的博客
03-10 1220
可以使用。
数据结构-栈&队列OJ题
m0_62183318的博客
01-17 2715
MyStack的成员不是队列指针，而是队列结构体变量，所以在myStackCreake中为MyStack动态开辟的空间大小是为两个队列结构体变量开辟的，这样做的好处是可以取q1和q2的地址，方便我们直接可以修改队列q1和q2。此时再入数据就要从rear的位置入，问题是入了数据后，rear+1就出了数组的下标范围，我们应该让rear回到0下标的位置才能真正实现循环队列：（注意：k是题目要求存储的元素个数）这道题是要用队列来实现栈，首先我们要了解到队列的性质是先进先出，而栈的性质是后进先出。
蓝桥杯 第2天 基本数据结构 栈&队列&链表
aixiaoxiao13的博客
01-19 829
目录 1.栈 2.使用栈来匹配括号 3.使用栈来匹配符号 4.用栈将十进制转为二进制 5.用栈将十进制转为任意进制 6.使用栈完成中序表达式往后序表达式转换 7.使用栈计算后序表达式的值 8.队列 列表实现队列 9.用队列玩传花游戏 10.双端队列 11.双端队列实现回文检测器 12.列表-&gt;链表 （1）node类 （2）链表的实现 1.栈 LIFO Last In First Out 用列表实现栈 class stack: def __init__
数据结构之栈和队列
慢慢记录，慢慢更新。
01-07 1150
栈（Stack）是一种特殊的线性数据结构，遵循“后进先出”（LIFO, Last In First Out）的原则。 队列（Queue）是一种特殊的线性数据结构，遵循“先进先出”（FIFO, First In First Out）的原则。
数据结构之栈与队列
bai_lan_ya的博客
05-07 2078
栈：队列：plaintext 队列： plaintext 4、典型应用场景 场景 栈的应用 队列的应用 函数调用 存储函数调用的参数、返回地址（系统栈自动管理）。 无直接应用，函数调用本质是栈结构。 表达式处理 后缀表达式求值、中缀转后缀（处理运算符优先级）。 无相关应用。 括号匹配 检测括号是否正确嵌套（如）。 无相关应用。 任务调度
Python数据结构&算法(03) 栈&队列
qq_42914862的博客
05-02 1401
Python数据结构&amp;算法(03) 栈和队列 文章目录Python数据结构&amp;算法(03) 栈和队列3.1 栈3.1.1 栈的基本操作3.1.2 链式栈3.2 队列3.2.1 队列的基本操作3.2.2 链式队列3.3.3 循环队列 3.1 栈 栈可以理解为只允许在表尾进行插入或删除的线性表，对栈而言，其表尾称为栈顶，相应的其表头端称为栈底，不含元素的空表称为空栈。 假设栈 S = (a1, a2, ..., an) ，则称 a1 为栈底元素，an 为栈顶元素。栈中元素是按照 a1, a2, .
day22-数据结构之 栈&&队列
m0_71289080的博客
05-16 730
链栈示意图：最好采取头插和头删。
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车&ldquo;到达&rdquo;或&ldquo;离去&rdquo;信息、汽车...
数据结构栈和队列（参考代码）
06-18
### 数据结构栈和队列知识点解析 #### 一、栈的基本概念与操作 **栈**是一种特殊的线性表，只允许在一端进行插入和删除操作，这一端被称为栈顶，另一端被称为栈底。栈遵循先进后出（First In Last Out, FILO）的...
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
15_嵌入式场景实战：用数据结构优化外设数据处理
最新发布
C语言无原生OOP特性，却能借结构体+函数指针实现封装、继承、多态，落地工厂等设计模式。博客中以标准C语法实操教学，融入跨平台兼容设计，助开发者掌握C语言OOP核心与工程实践技巧。
01-02 740
嵌入式开发不是“能跑就行”，而是“在有限资源下跑得稳、跑得快”。串口缓存用环形队列、时序数据用链表、协议解析用哈希表——这些看似基础的数据结构，恰恰是解决外设数据处理痛点的关键。今天的代码片段可以直接移植到你的项目中，记得根据MCU型号和实际场景调整参数（如缓冲区大小、哈希表长度）。如果这篇内容帮你解决了实际开发中的问题，别忘了！后续还会分享更多嵌入式实战技巧，比如中断优化、内存管理、低功耗设计等，让你的代码既稳定又高效～
Redis 7 底层数据结构
WenZhang的博客
12-28 1342
Redis 7采用对象系统架构，所有数据存储在redisObject中，包含类型、编码、引用计数等元数据。字符串系统使用5种SDS结构，根据长度自动选择最优编码（INT/EMBSTR/RAW）。列表结构采用QuickList复合设计，结合双向链表与紧凑列表，通过智能压缩策略平衡内存与性能。哈希、集合等类型根据元素数量/大小自动选择最优编码（如LISTPACK或哈希表），实现内存高效利用。Redis 7通过精细化的数据结构设计和自适应编码转换机制，在保证高性能的同时优化内存使用。
数据结构--队列
2501_90980137的博客
12-28 294
• 入队（enqueue）：在队尾添加元素，若队列满则抛出异常或进行扩容。• 出队（dequeue）：删除并返回队头元素，若队列为空则抛出异常。队列是先进先出（FIFO）的线性数据结构，元素从队尾入队，队头出队。◦ 用单链表存储元素，队头指向链表头节点，队尾指向链表尾节点。• 判空（isEmpty）：判断队列中是否存在元素。• 查看队头（peek）：返回队头元素但不删除。• 查看大小（size）：获取队列中元素的个数。• 任务排队（如打印机任务队列、线程池任务队列）1. 数组实现（顺序队列）
数据结构--学生管理系统
2501_90980137的博客
12-28 343
System.out.println("学号：" + temp.id + " 姓名：" + temp.name + " 年龄：" + temp.age);manager.addStudent(new Student("001", "张三", 20));System.out.println("学号重复，添加失败");System.out.println("暂无学生信息");System.out.println("未找到该学生");◦ 查询：支持按学号精准查询、按姓名模糊查询，以及遍历展示所有学生。
数据结构(十一) 哈希表
C/C++技术栈
12-28 1038
哈希表是一种高效的查找结构，通过哈希函数建立关键码与存储位置的映射关系，实现O(1)的平均查找时间复杂度。文章详细介绍了两种哈希冲突解决方法：开放地址法（线性探测和二次探测）和链地址法（哈希桶），并分析了负载因子对性能的影响。同时阐述了哈希函数设计原则和常见方法（直接定址法、除留余数法等），并提供了C++实现代码，包括插入、查找、删除等核心操作。针对字符串等非整型数据，还介绍了特化的哈希函数处理方法。通过对比两种冲突解决方式的优缺点，为实际应用提供了选择依据。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hehelm

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值