栈和队列（stack和queue）

已于 2023-03-21 16:51:45 修改
阅读量714 收藏 6
点赞数 10
分类专栏： 数据结构 文章标签： 数据结构 链表 c语言 开发语言
于 2023-03-20 01:00:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70056514/article/details/129658821
版权

目录

一、栈

1.1 什么是栈？

栈 (Stack)是一种线性存储结构，它具有如下特点： 栈中的数据元素遵守”后进先出” (First In Last Out)的原则，简称FILO结构。 限定只能在栈顶进行插入和删除操作。
栈顶与栈底：允许元素插入与删除的一端称为栈顶，另一端称为栈底。栈可以用动态数组的方式实现，也可以用链表来实现。以下是用动态数组的方式模拟实现栈。

1.2 栈的相关操作

1.2.1 结构体变量的声明

typedef int StackDataType;

typedef struct Stack
{
	//这里就是一个指向动态开辟内存的指针即可
	//和顺序表一个道理
	StackDataType* a;
	//top记录栈顶位置，top的初始值为0或者-1取决于
	//设计者设计top位置是栈顶元素的位置(top=-1)
	//还是栈顶元素位置的下一个(top=0)。
	int top;
	//capacity是栈的容量，容量不够就增容
	int capacity;
}ST;

1.2.2 栈的初始化

void STInit(ST* st)
{
	assert(st);
	//开辟空间
	st->a = (StackDataType*)malloc(sizeof(StackDataType) * 4);
	if (st->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	st->capacity = 4;
	//st->top=0代表top是栈顶元素的下一个位置的下标而并非栈顶元素的下标
	st->top = 0;
}

1.2.3 栈的销毁

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

}

1.2.4 元素入栈

void STPush(ST* st, StackDataType x)
{
	assert(st);
	if (st->capacity == st->top)
	{
		//增容
		StackDataType* tmp = (StackDataType*)realloc(st->a, sizeof(StackDataType) * (st->capacity * 2));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		st->a = tmp;
		st->capacity *= 2;
	}

	//top位置是栈顶元素位置的下一个，所以直接把x入栈到top下标的位置
	st->a[st->top] = x;
	st->top++;

}

1.2.5 元素出栈

void STPop(ST* st)
{
	//出栈的条件之一是栈内必须有数据
	//所以不能为空
	assert(st && !STEmpty(st));
	//直接top--即可
	st->top--;
}

1.2.6 取栈顶元素

StackDataType STTop(ST* st)
{
	assert(st);
	//要取元素，栈不能为空
	assert(!STEmpty(st));
	//由于top是栈顶的下一个位置的下标，所以需要返回top-1位置的元素
	return st->a[st->top - 1];
}

1.2.7 求栈里面元素的数目

size_t STSize(ST* st)
{
	assert(st);
	//由于top是有0开始的，插入一个数据就+1
	//所以插入了多少个数据top就是多少，所以直接返回top的大小即可
	return st->top;
}

1.2.8 判断栈是否为空

bool STEmpty(ST* st)
{
	assert(st);
	//如果top==0，证明栈内无数据，
	//栈为空，st->top==0的逻辑结果true，直接返回即可
	return st->top == 0;
}

1.3 栈的代码汇总

1.3.1 Stack.h

#pragma once

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

typedef int StackDataType;

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

extern void STInit(ST* st);
extern void STDestroy(ST* st);
extern void STPush(ST* st, StackDataType x);
extern void STPop(ST* st);
extern StackDataType STTop(ST* st);
extern size_t STSize(ST* st);
extern bool STEmpty(ST* st);

1.3.2 Stack.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "Stack.h"

void STInit(ST* st)
{
	assert(st);
	//开辟空间
	st->a = (StackDataType*)malloc(sizeof(StackDataType) * 4);
	if (st->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	st->capacity = 4;
	//st->top=0代表top是栈顶元素的下一个的位置的下标而并非栈顶元素的下标
	st->top = 0;
}

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

}

void STPush(ST* st, StackDataType x)
{
	assert(st);
	if (st->capacity == st->top)
	{
		//增容
		StackDataType* tmp = (StackDataType*)realloc(st->a, sizeof(StackDataType) * (st->capacity * 2));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		st->a = tmp;
		st->capacity *= 2;
	}

	//top位置是栈顶元素位置的下一个，所以直接把x入栈到top下标的位置
	st->a[st->top] = x;
	st->top++;

}


void STPop(ST* st)
{
	assert(st && !STEmpty(st));
	//直接top--即可
	st->top--;
}

StackDataType STTop(ST* st)
{
	assert(st);
	//要取元素，栈不能为空
	assert(!STEmpty(st));
	//由于top是栈顶的下一个位置的下标，所以需要返回top-1位置的元素
	return st->a[st->top - 1];
}

size_t STSize(ST* st)
{
	assert(st);
	//由于top是有0开始的，插入一个数据就+1
	//所以插入了多少个数据top就是多少，所以直接返回top的大小即可
	return st->top;
}

bool STEmpty(ST* st)
{
	assert(st);
	//如果top==0，证明栈内无数据，
	//栈为空，st->top==0的逻辑结果true，直接返回即可
	return st->top == 0;
}

1.3.3 test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "Stack.h"

int main()
{
	ST st;
	STInit(&st);
	STPush(&st, 1);
	STPush(&st, 2);
	STPush(&st, 3);
	STPush(&st, 4);
	STPush(&st, 5);
	while (!STEmpty(&st))
	{
		printf("%d ", STTop(&st));
		STPop(&st);
	}
	printf("\n");


	STDestroy(&st);
	return 0;
}

二、队列

2.1 什么是队列？

队列(Queue)也是一种线性的存储结构，它具有如下特点： 队列中的数据元素遵守”先进先出” (First In First Out)的原则，简称FIFO结构。 限定只能在队列的尾部进行插入数据，头部进行删除数据。
队列适合用单链表实现，因为单链表头删和尾插的时间复杂度是O(1)的，效率很高。

2.2 队列相关操作

2.2.1 结构体变量的声明

typedef int QNodeDataType;

//队列的每一个元素是一个结构体
typedef struct QueueNode
{
	//每一个结点内都存着下一个结点的指针(地址)
	struct QueueNode* next;
	//结点的有效数据
	QNodeDataType data;

}QNode;

typedef struct Queue
{
	//队列最好定义一个指向头节点的指针和
	//一个指向尾节点的指针，方便头删和尾插，提高效率
	QNode* head;
	QNode* tail;
	//记录队列一共有多少个结点，每插入一个结点就+1
	int size;

}Queue;

2.2.2 队列的初始化

void QueueInit(Queue* pq)
{
	assert(pq);
	//空队列的头和尾指针都要指向NULL
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
	
}

2.2.3 队列的销毁

void QueueDestroy(Queue* pq)
{
	assert(pq);
	
	//由于每一个结点都是malloc出来的，所以
	//需要遍历逐一释放队列内的结点，防止内存泄露
	QNode* cur = pq->head;
	while (cur)
	{
		//先保存需要释放的结点del，释放后cur迭代地走下去
		//直到cur为空就全部释放完了
		QNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

2.2.4 队列的插入

void QueuePush(Queue* pq, QNodeDataType x)
{
	assert(pq);

	//申请结点
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		perror("");
		return;
	}
	newNode->data = x;
	newNode->next = NULL;

	//第一次插入时由于队列为空，所以pq->head和pq->tail
	//都为空，则应该直接赋值结点的结构体给p->head和pq->tail
	//如果直接pq->tail->next = newNode程序会崩的，因为pq->tail为空
	//不能访问
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newNode;
	}
	else
	{
		//插入到尾部
		pq->tail->next = newNode;

		//newNode更新为新的尾结点
		pq->tail = newNode;
	}

	//队列的数据数目+1
	pq->size++;
}

2.2.5 队列的删除

void QueuePop(Queue* pq)
{
	assert(pq);

	//删除的前提是不能队列为空
	assert(!QueueEmpty(pq));

	//如果只有一个结点的话，那删掉这个结点
	//同时把尾指针要置为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;
	}

	//数目-1
	pq->size--;

}

2.2.6 队列元素的数目

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

2.2.7 判断队列是否为空

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

2.2.8 取队列头部的元素

QNodeDataType QueueFront(Queue* pq)
{
	assert(pq);
	//取元素的前提是队列不能为空
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

2.2.9 取队列尾部的元素

QNodeDataType QueueBack(Queue* pq)
{
	assert(pq);
	//取元素的前提是队列不能为空
	assert(!QueueEmpty(pq));

	return pq->tail->data;

}

2.3 队列的代码汇总

2.3.1 Queue.h

#pragma once

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

typedef int QNodeDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QNodeDataType data;

}QNode;

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

}Queue;

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

2.3.2 Queue.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "Queue.h"

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

void QueueDestroy(Queue* pq)
{
	assert(pq);
	
	//由于每一个结点都是malloc出来的，所以
	//需要遍历逐一释放队列内的结点，防止内存泄露
	QNode* cur = pq->head;
	while (cur)
	{
		//先保存需要释放的结点del，释放后cur迭代地走下去
		//直到cur为空就全部释放完了
		QNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QNodeDataType x)
{
	assert(pq);

	//申请结点
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		perror("");
		return;
	}
	newNode->data = x;
	newNode->next = NULL;

	//第一次插入时由于队列为空，所以pq->head和pq->tail
	//都为空，则应该直接赋值结点的结构体给p->head和pq->tail
	//如果直接pq->tail->next = newNode程序会崩的，因为pq->tail为空
	//不能访问
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newNode;
	}
	else
	{
		//插入到尾部
		pq->tail->next = newNode;

		//newNode更新为新的尾结点
		pq->tail = newNode;
	}

	//队列的数据数目+1
	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);

	//删除的前提是不能队列为空
	assert(!QueueEmpty(pq));

	//如果只有一个结点的话，那删掉这个结点
	//同时把尾指针要置为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;
	}

	//数目-1
	pq->size--;

}

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

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

QNodeDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QNodeDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;

}

2.3.3 test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "Queue.h"

int main()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);

	/*printf("%d ", QueueFront(&q));
	QueuePop(&q);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);*/


	while (!QueueEmpty(&q))
	{
		printf("QueueFront:%d ", QueueFront(&q));
		printf("size = %d\n", QueueSize(&q));
		QueuePop(&q);
	}
	QueueDestroy(&q);

	return 0;
}

以上就是用C语言实现栈和队列的所有内容，你学会了吗？喜欢的在评论区留下一颗小心心点点关注呗！！！

Gay~
关注
  • 10
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
【C++】栈和队列（stack&queue）
love_guanghui的博客
12-01 3068
栈和队列 一.stack的介绍和使用 （1）概念 ·stack是一种后进先出的容器结构，准确来说stack并不是容器，而是一种容器适配器（对特定类封装作为其底层的容器）。 ...
栈和队列的代码
05-20
栈和队列的代码 stack queue 的建立和方法
栈（stack）与队列（queue）
LANGJ1的博客
09-26 818
栈 栈（stack）是限制对元素的插入（push）和删除（pop）只能在一个位置上进行的表，该位置是表的末端，叫做栈的栈顶（top)。 初次理解栈，你可以把它理解为一种特殊的数组，元素在栈顶添加和删除。栈且对栈遵循后进先出（LIFO——Last In First Out）的原则。 ...
NVMe系列专题之二：队列(Queue)管理
redseazhaojianertao的博客
12-01 1万+
转载链接：https://mp.weixin.qq.com/s?__biz=MzIwNTUxNDgwNg==&amp;mid=2247484355&amp;idx=1&amp;sn=04f0617bf774fa3c6020d90288b679e8&amp;chksm=972ef29aa0597b8ca79b040f3222eef85835a5cd693167aa6f7ffd34a78ae15f69...
STL详解（七）—— stack和queue的介绍及使用
2021dragon的博客
09-04 1788
文章目录stackstack的定义方式stack的使用queuequeue的定义方式queue的使用 stack 栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 stack的定义方式 方式一： 使用默认的适配器定义栈。 stack<int> st1; 方式二： 使用特定的适配器定义栈。 stack<int, vector<int
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
C++ STL——栈和队列（stack & queue）
希望自己从编程小白变成大佬
12-19 1502
2.1 queue的介绍queue的文档介绍根据queue的文档介绍可以知道,队列是一种容器适配器，专门设计用于在 FIFO 上下文（先进先出）中运行，其中元素插入容器的一端并从另一端提取。队列作为容器适配器实现，容器适配器是使用特定容器类的封装对象作为其基础容器的类，提供一组特定的成员函数来访问其元素。元素被推入特定容器的“背面”(即队尾)，并从其“正面”(即队头)弹出。基础容器可以是标准容器类模板之一，也可以是其他一些专门设计的容器类。emptysize。
栈stack和队列
YWX
01-30 1万+
栈和队列一· 栈和队列二· 栈三.队列四.例题 一· 栈和队列 栈和队列是两种重要的线性结构。从数据结构来看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表操作的子集（也具有顺序结构和链式结构），它们是操作受限的线性表，因此，可称为限定性的数据结构。 二· 栈 定义 ：只能在表的一端（栈顶）进行插入和删除运算的线性表。 逻辑结构：与线性表相同，仍为一对一关系。 存储结构：用顺序栈或链栈存储均可，但以顺序栈更常见。 链栈： 运算规则：只能在栈顶运算，且访问结点时依照后进先出（LIFO）或先进后出
【详解栈Stack与队列Queue】
TheMyth142857的博客
05-24 2053
本章主要介绍了栈和队列这两种数据结构，它们属于特殊线性表，通常在学习栈的时候对比学习队列。本文如有不足之处，请广大读者提出宝贵意见！！！谢谢！！！
队列（Queue）和栈(Stack)
qq_42688149的博客
05-15 709
队列Queue 和 栈Stack https://blog.csdn.net/rocling/article/details/103834545 https://www.cnblogs.com/ibelieve618/p/6380328.html
C++ stack&&queue 栈和队列的使用&&模拟实现
weixin_57761086的博客
10-03 2013
讲解C++的栈和队列的使用与模拟实现。模拟实现中，用文字叙述来帮助读者更好地理解堆和栈的模拟实现。
stack-and-queue-.zip_栈和队列
09-14
数据结构 栈和队列及其应用 对栈进行一些操作
Queue_栈队列_pop_
09-30
任务描述栈和队列都提供 Push/Pop 两... 输出描述对每组测试数据输出一行， 输出该组数据对应的线性结构，若为栈则输出”Stack”，若为队列则输出“Queue”，若两者都是则输出“Both”，若两者都不是则输出“Error”。
栈和队列.docx 栈（Stack）和队列（Queue）是两种常见的数据结构
04-03
栈（Stack）和队列（Queue）是两种常见的数据结构，它们都可以用来存储和管理数据，但它们在数据访问的方式上有所不同。 1. **栈（Stack）**： - 栈是一种后进先出（Last In, First Out，LIFO）的数据结构，类似于...
栈和队列(C版本).rar
09-23
栈和队列(C版本)源代码，欢迎大家下载学习。如果有疑问也可以给我留言。谢谢！
数据结构-绪论
最新发布
pyc68的博客
06-17 462
本篇文章先介绍数据结构的研究内容，然后再介绍如何去理解数据结构，着重介绍表示数据结构关系的逻辑结构和存储结构（物理结构）。
数据结构-树的性质
WinterXJujube的博客
06-09 263
树是一个有限数据元素的集合，当数据的量为0时，称为空树。在一个非空树T中，最上方的结点没有前驱结点，称为根节点。在一个数据量大于1的树中，除了根节点之外的其余数据元素可以被分为m个互不相交的集合T1,T2,T3等。其中每一个集合T都可以看作一个单独的树，称为整个树的子树。树拥有层级结构，而这种层级结构由递归实现。从根节点开始，根节点为第一层。经过一次递归得到的结点称为第二层，以此类推。而如果同一层的节点之间互相连通，则不成为树结构。
初识数据结构-B树
LeoLei8060的博客
06-17 373
B树是一种多路搜索树（即每个节点可以有多个子节点）。在B树中，每个节点可以包含多个键（和相应的值）以及指向其子节点的指针。B树通过重新分布键值和拆分节点来保持平衡，从而确保树的高度保持较低。
嵌入式学习——数据结构（单向无头链表）——day46
qq_47798402的博客
06-17 97
它不仅包括数据元素的存储方式，还包括数据元素之间的关系，以及对数据进行操作的方法和算法。数据结构的选择和设计直接影响算法的效率和程序的性能，是计算机科学与编程中非常重要的基础。它衡量的是算法的执行时间随输入规模的变化情况，通常用大O记号表示，如O(n)、O(log n)等。3. 散列存储（哈希存储）将数据元素的存储位置与关键码之间建立确定对应关系从而实现查找的存储方式。顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列、二叉树、哈希表。1. 线性结构（一对一）表、数组、链表、队列、栈。
java栈和队列判断回文
12-21
在Java中，可以使用栈和队列来判断一个字符串是否是回文。下面是一个示例代码： ```java import java.util.*; public class PalindromeChecker { public static boolean isPalindrome(String str) { // 创建一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值