数据结构之栈和队列(C语言版)

最新推荐文章于 2024-07-25 19:28:17 发布
最新推荐文章于 2024-07-25 19:28:17 发布
阅读量855 收藏 23
点赞数 25
分类专栏： 数据结构笔记(C语言版) 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A2885A/article/details/140508558
版权

一. 前言

各位读者朋友们大家好，上期我们讲完了单链表的结构以及代码实现，这期我们一起来学习栈和队列并且用C语言来实现这两个数据结构。首先我们先来学习栈。

二. 栈

1. 栈的概念及结构

1.1 栈的概念

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端
称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

  • 压栈：将数据插入栈的操作叫做压栈，插入的元素在栈顶。
  • 出栈：栈的删除操作叫做出栈。出数据也在栈顶。
    在这里插入图片描述

1.2 栈的结构

这里我们选择用顺序表的结构来实现栈。
在这里插入图片描述

typedef int STDadaType;
typedef struct Stack
{
	STDadaType* arr;
	int top;//指向栈顶元素的下一个位置
	int capacity;
}ST;

2. 栈的实现

栈要实现以下的接口：

  • 1.栈的初始化和销毁
  • 2.入栈和出栈
  • 3.取栈顶元素
  • 4.判空
  • 5.栈的元素个数

下面我们来一一实现这些接口。

2.1 栈的初始化和销毁

2.1.1 栈的初始化
void STInit(ST* pst)
{
	assert(pst);
	pst->arr = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

栈的初始化的实现和顺序表的初始化是一样的。这里我们将top初始化为0，top指向栈顶的下一个位置，top也就等价于顺序表中的size。
在这里插入图片描述

2.1.2 栈的销毁
void STDestroy(ST* pst)
{
	assert(pst);

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

arr的空间是动态申请开辟的，在不使用后要将它释放掉，并将它置为空指针来规避野指针。

2.2 入栈和出栈

2.2.1 入栈

入栈就是压栈，将数据插入到栈顶，因为我们是使用的顺序表结构，因此入栈也就相当于在顺序表的末尾插入元素。我们在初始化栈的时候将top初始化为0，那么也就意味着top是指向栈顶元素的后一个位置。因此，入栈就是在top位置插入数据。

void STPush(ST* pst, STDadaType x)
{
	assert(pst);
	//扩容
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDadaType* tmp = (STDadaType*)realloc(pst->arr, sizeof(STDadaType) * newcapacity);
		if (tmp == NULL)
		{
			perror("rrealloc fail");
			return;
		}
		pst->arr = tmp;
		pst->capacity = newcapacity;
	}
	pst->arr[pst->top++] = x;
}

在入栈的时候我们也要考虑空间的问题，当top和capacity相等时，也就是栈满或栈为空的情况下要扩容。在插入数据后，记得top++。

2.2.2 出栈

出栈就是将栈顶的元素删除，也就相当于顺序表的尾删，只需要将top-1即可。

void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}

2.3 取栈顶元素

因为我们的top初始化为0，所以栈顶元素是在top-1的位置。

STDadaType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->arr[pst->top - 1];
}

2.4 判空

栈的元素为零即为空。

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

2.5 栈的元素个数

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

3. 栈的元素打印

因为栈中的元素是后进先出的，因此在打印的时候，我们要将栈顶的元素删除后再打印下一个元素。

int main()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	STPush(&s, 4);
	while (!STEmpty(&s))
	{
		printf("%d ", STTop(&s));
		STPop(&s);
	}
	STDestroy(&s);
	return 0;
}

但是注意，出栈的顺序不一定是最后进的先出，也可以边进边出。

int main()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	printf("%d ", STTop(&s));
	STPop(&s);
	STPush(&s, 3);
	STPush(&s, 4);
	while (!STEmpty(&s))
	{
		printf("%d ", STTop(&s));
		STPop(&s);
	}
	STDestroy(&s);
	return 0;
}

在这里插入图片描述
这样，我们在将2入栈之后接着出栈了。
以上，我们就讲完了栈这一数据结构，接下来我们讲队列这个数据结构。

三. 队列

1. 队列的概念及结构

1.1 队列的概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 。

  • 入队列：进行插入操作的一端称为队尾
  • 出队列：进行删除操作的一端称为队头

1.2 队列的结构

这里我们选择使用链表结构实现队列。
在这里插入图片描述

typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QNode;

因为我们在后续接口中要使用队列的头指针和尾指针，我们创建一个结构体来存储头指针和尾指针，以及队列中有效元素的个数，这样也规避了使用二级指针。

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

2. 队列的实现

队列要实现以下的接口：

  • 队列的初始化和销毁
  • 出队列和入队列
  • 获取队列头部和尾部数据
  • 判空
  • 获取队列有效元素个数

2.1 队列的初始化和销毁

2.1.1 队列的初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
2.1.2 队列的销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

这里的next指针记录下一个节点，避免释放后找不到下一个节点。

2.2 出队列和入队列

2.2.1 入队列

当队列为空时，我们在队列中插入数据，头指针和尾指针都指向新插入的节点，当不为空时，就相当于链表尾插节点。

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->val = x;
	newnode->next = NULL;
	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

因为只有在入队列的时候才会创建节点，因此创建节点的功能就在入队列的函数中实现。

2.2.2 出队列

因为队列是先进先出的数据结构，因此出队列就相当于是链表的头删。在这里我们要考虑一下队列中只有一个结点的情况。
在这里插入图片描述
在我们将这个节点释放后，头指针指向了空，但是尾指针还是指向原来的地址，当我们再次使用尾指针时，尾指针就成了野指针，因此我们在这种情况下也要将尾指针置空。

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);//队列不为空
	if (pq->phead->next == NULL)//只有一个节点
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	pq->size--;
}

3. 获取队列头部和尾部数据

3.1 获取队列头部元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->val;
}
3.2 获取队列尾部元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

4. 获取队列有效元素个数

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

5. 判空

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

四. 整体代码呈现

1. 栈

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDadaType;
typedef struct Stack
{
	STDadaType* arr;
	int top;//指向栈顶元素的下一个位置
	int capacity;
}ST;
//初始化和销毁
void STInit(ST* pst);
void STDestroy(ST* pst);
//入栈和出栈
void STPush(ST* pst, STDadaType x);
void STPop(ST* pst);
//取栈顶元素
STDadaType STTop(ST* pst);
//判空
bool STEmpty(ST* pst);
//元素个数
int STSize(ST* pst);

Stack.c

#include"Stack.h"
//初始化和销毁
void STInit(ST* pst)
{
	assert(pst);
	pst->arr = NULL;
	pst->top = 0;
	pst->capacity = 0;
}
void STDestroy(ST* pst)
{
	assert(pst);

	free(pst->arr);
	pst->arr = NULL;
	pst->capacity = pst->top = 0;
}
//入栈和出栈
void STPush(ST* pst, STDadaType x)
{
	assert(pst);
	//扩容
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDadaType* tmp = (STDadaType*)realloc(pst->arr, sizeof(STDadaType) * newcapacity);
		if (tmp == NULL)
		{
			perror("rrealloc fail");
			return;
		}
		pst->arr = tmp;
		pst->capacity = newcapacity;
	}
	pst->arr[pst->top++] = x;
}
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}
//取栈顶元素
STDadaType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->arr[pst->top - 1];
}
//判空
bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}
//元素个数
int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

2. 队列

Queue.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QNode;
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;
//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestroy(Queue* pq);
//入队列
void QueuePush(Queue* pq, QDataType x);
//出队列
void QueuePop(Queue* pq);
//获取队列头部数据
QDataType QueueFront(Queue* pq);
//获取队列尾部数据
QDataType QueueBack(Queue* pq);
//获取队列有效元素个数
int QueueSize(Queue* pq);
//判空
bool QueueEmpty(Queue* pq);

Queue.c

#include"Queue.h"

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
//入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->val = x;
	newnode->next = NULL;
	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}
//出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);//队列不为空
	if (pq->phead->next == NULL)//只有一个节点
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	pq->size--;
}
//获取队列头部数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->val;
}
//获取队列尾部数据
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}
//获取队列有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

五. 结语

以上我们就讲完了栈和队列这两个数据结构，希望对大家有帮助，欢迎大家批评指正！

跃渊Yuey
关注
  • 25
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构中的栈和队列-C语言版
qq_32169165的博客
05-30 290
1、数据结构概述 栈和队列，也属于线性表，因为它们也都用于**存储逻辑关系为 "一对一"** 的数据，但由于它们比较特殊，因此将其单独作为一章，做重点讲解。 使用栈结构存储数据，讲究“先进后出”，即最先进栈的数据，最后出栈；使用队列存储数据，讲究 "先进先出"，即最先进队列的数据，也最先出队列。 栈也可分为顺序栈和链表，队列也分为顺序队列和链队列， 也就是说，栈和队列都可以使用数组和链表两种线性结构来表示。 1.1 栈 常见的栈操作 push(x) – 元素 x 入栈 （时
C语言数据结构：栈和队列
qq_42319810的博客
07-02 1050
define MaxSzie 10 //定义栈中元素的最大个数//静态数组存放栈中元素int top;//栈顶指针}SqStack;//初始化栈S.top = -1;//初始化栈顶指针SqStack S;//声明一个顺序栈（分配空间）.....//判空操作else//数据域//指针域}*LiStack;//栈类型定义队列（Queue）是只允许在一端进行插入，在另一端删除的线性表重要术语：队头、队尾、空队列。
《数据结构C语言版》——栈和队列详解(图文并茂)，从零开始的学习
青春无问西东 岁月自成芳华
04-20 4639
一文搞懂数据结构系列之栈和队列部分，从0基础到快速手敲数据结构，小白也能轻松看懂的宝典！
数据结构之栈和队列-思路清晰纯C
08-31
队列 循环队列 栈 内容学习于 https://www.bilibili.com/video/BV1W64y1z7jh?p=19&spm_id_from=pageDriver&vd_source=4d33bf4ac4499f2c0370694554a02fa5
c语言数据结构-栈队列数组完美版资料.ppt
11-14
本资源摘要信息主要关于C语言数据结构中的栈、队列和数组三个基本概念。...栈、队列和数组是C语言数据结构中的三个基本概念，栈的实现需要考虑到实际情况，栈的应用非常广泛，栈的优点和缺点需要被正确地考虑。
数据结构---栈和队列之共享栈（C语言）
05-05
数据结构---栈和队列之共享栈（C语言）完整代码，可以运行
c语言（7.23）
fhgfyrsg的博客
07-23 437
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 776
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 392
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 361
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
数据结构——单链表OJ题（下）
最新发布
2301_81888634的博客
07-25 595
链表既然包括单链表，就还有其他种类啦~敬请期待“双向链表”~
数据结构（特殊二叉树-平衡二叉树）
weixin_65029285的博客
07-23 951
待删除节点左右子树非空，则根据左右子树的高度，选择高的一边子树，如果是左子树高，选择左子树中的最大节点赋值给待删除节点，然后再左子树中继续删除该最大节点，相当于继续处理情况1或情况2；由于节点的位置要受到相互之间值的影响，并且在往平衡二叉树中添加节点或者删除节点前，二叉树本身是平衡的，所以只可能在最后操作的节点附近不满足平衡条件，因此需要在该过程中对该节点进行判断并调整。如果一个搜索二叉树呈现或接近单支状，它的查找效率很低，很接近链表，因此如果能让它平衡时，查找效率最高。待删除的节点是叶子节点，直接删除。
华清数据结构day5 24-7-22
m0_62859255的博客
07-22 394
【代码】华清数据结构day5 24-7-22。
【数据结构】AVL树(平衡二叉搜索树)
weixin_69380220的博客
07-24 1079
AVL树的相关操作
数据结构——二叉树定义
鲸落博客
07-23 403
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
 数据结构栈和队列c语言
10-19
栈和队列是两种常见的数据结构，它们都可以用来存储一系列的数据，并且具有不同的特点和应用场景。 栈是一种后进先出（Last In First Out，LIFO）的数据结构，类似于一个＊＊＊、表达式求值、括号匹配等。 队列是一种先进先出（First In First Out，FIFO）的数据结构，类似于排队。队列的基本操作包括入队（enqueue）和出队（dequeue），入队将数据放入队尾，出队将队头数据弹出。队列的应用场景包括广度优先搜索、任务调度等。 在C语言中，栈和队列可以用数组或链表来实现。引用和分别介绍了链队列和顺序队列的存储结构，而引用则介绍了循环队列的实现方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值