数据结构之栈和队列（c语言实现篇）

最新推荐文章于 2024-07-12 16:27:59 发布
最新推荐文章于 2024-07-12 16:27:59 发布
阅读量353 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CHAKMING1/article/details/125909221
版权

数据结构之栈和队列（c语言实现篇）

本篇博客介绍数据结构中栈和队列的概念、实现方式以及相关的面试题

文章目录

1. 栈

1.1 栈的概念及结构

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

压栈：栈的插入操作叫做进栈/压栈/入栈，入的数据元素在栈顶。

出栈：栈的删除操作叫做出栈，出的数据元素在栈顶。

在这里插入图片描述

1.2 栈的实现

栈的实现与线性表的实现相似，可以采用数组或者链表实现。栈底固定不变，只改变栈顶，那么这里只需要一个指向栈顶的指针即可。对于栈来说，通常使用数组实现会更加方便，在实际中很少使用静态栈，所以下面代码采用动态栈的实现方式。

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

// 结构
typedef int STDataType;
typedef struct Stack
{
    STDataType* _a;
    int _top;               // 栈顶
    int _capacity;       // 容量
}ST;
// 具体操作
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素的个数
int StackSize(Stack* ps);
// 判断栈是否为空，为空返回非0，空返回0
int StackEmpty(Stack* ps);
// 销毁栈
void StackDestory(Stack* ps);
1.2.1 栈的初始化和销毁操作
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_top = 0;
	ps->_capacity = 0;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}
1.2.2 栈的入栈

在这里插入图片描述

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
       // 判断是否有足够容量
	if (ps->_top == ps->_capacity)
	{
		int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		
		ps->_a = tmp;
		ps->_capacity = newCapacity;
	}
	// 这里才是插入操作，可以合并为ps->_a[ps->_top++] = x;
	ps->_a[ps->_top] = x;
	ps->_top++;
}
1.2.3 栈的出栈

栈的出栈只需要将栈顶元素减减即可

void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->_top--;
}
1.2.4 栈的其余操作
// 返回栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->_a[ps->_top - 1];
}
// 判断栈是否为空
int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->_top == 0;
}
// 返回当前栈的有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->_top;
}

2. 队列

2.1 队列的概念及结构

队列：队列本质上也是一种特殊的线性表，只允许在一端进行插入操作，在另一端进行删除操作。进行数据插入操作的一端称为队尾，进行删除操作的称为队头。队列中的元素遵守**先进先出（FIFO）**的原则。

在这里插入图片描述

2.2 队列的实现

队列的实现同样可以采用数组和链表结构，但用链表实现队列会更加方便，如果采用数组实现队列要考虑循环队列的问题。

#pragma once

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

// 每个结点结构
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

// 队列结构
typedef struct Queue
{
	//int size;
	QNode* head; // 指向队头
	QNode* tail; // 指向队尾
}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 QueueEmpty(Queue* pq);
// 返回队列元素个数
int QueueSize(Queue* pq);
2.2.1 队列的初始化和销毁操作

使用链表进行销毁，需要先将每个结点进行free操作，再将头指针和尾指针初始化

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

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;
}
2.2.2 队列的入队

入队操作，首先要创建一个新的结点，这里要做一个判断，如果当前插入的队列并没有任何元素，需要同时修改头指针和尾指针指向新的结点。

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

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
2.2.3 队列的出队

在出队操作进行的时候，首先要判断当前队列是否为空，如果不为空，还需要对当前要出队的元素是否是唯一一个元素，如果是，则需要同时修改队头和队尾指针。

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

	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;
	}
}
2.2.4 队列的其余操作
// 返回队头元素
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;
}
// 判断是否为空
int QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}
// 求出队列的元素个数，与栈不同，这里遍历整个队列，也可以采用对队列结构加入size
int QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	int size = 0;
	while (cur)
	{
		++size;
		cur = cur->next;
	}

	return size;
}

3. 栈和队列面试题

232.用栈实现队列

实现思路：创建两个栈，一个作为输入栈，一个作为输出栈，插入元素的时候只需要将值插入到元素栈中，删除元素的时候，对输出栈进行判断，如果输出栈为空，需要将输入栈的元素加入到输出栈中，然后再加输出栈的元素出栈，peek操作是返回队头元素，这时候只需要调用队列的出队操作，将结果返回一个临时变量，再将出栈的值重新插入输出栈，判空只需要对输入栈和输出栈进行判断即可。

代码如下：（需要将我们写好的栈写入进去）

typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;               // 栈顶
	int _capacity;       // 容量
}Stack;

void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_top = 0;
	ps->_capacity = 0;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	// 判断是否有足够容量
	if (ps->_top == ps->_capacity)
	{
		int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		ps->_a = tmp;
		ps->_capacity = newCapacity;
	}
	// 这里才是插入操作，可以合并为ps->_a[ps->_top++] = x;
	ps->_a[ps->_top] = x;
	ps->_top++;
}

void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->_top--;
}

// 返回栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->_a[ps->_top - 1];
}
// 判断栈是否为空
int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->_top == 0;
}
// 返回当前栈的有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->_top;
}

typedef struct {
	Stack stIn;  // 输入栈
	Stack stOut; // 输出栈
} MyQueue;


MyQueue* myQueueCreate() {
	MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
	StackInit(&obj->stIn);
	StackInit(&obj->stOut);
	return obj;
}

void myQueuePush(MyQueue* obj, int x) {
	StackPush(&obj->stIn, x);
}

int myQueuePop(MyQueue* obj) {
	// 当输出栈为空时
	if (StackEmpty(&obj->stOut)) {
		// 将输入栈元素依次插入到输出栈
		while (!StackEmpty(&obj->stIn)) {
			StackPush(&obj->stOut, StackTop(&obj->stIn));
			StackPop(&obj->stIn);
		}
	}
	int result = StackTop(&obj->stOut);
	StackPop(&obj->stOut);
	return result;
}

int myQueuePeek(MyQueue* obj) {
	int res = myQueuePop(obj);
	StackPush(&obj->stOut, res);
	return res;
}

int myQueueEmpty(MyQueue* obj) {
	return StackEmpty(&obj->stIn) && StackEmpty(&obj->stOut);
}

void myQueueFree(MyQueue* obj) {
	StackDestroy(&obj->stIn);
	StackDestroy(&obj->stOut);
	free(obj);
}

225.用队列实现栈

实现思路：采用单队列实现方式，入栈操作只需要将值直接插入到队列中，出栈操作需要将队列的前面元素进行出队，然后重新插入到队尾中，然后再进行删除头元素操作。其余操作只需要对队列进行操作即可。

代码如下：（需要将我们写好的队列写入进去）

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

// 队列结构
typedef struct Queue
{
	//int size;
	QNode* head; // 指向队头
	QNode* tail; // 指向队尾
}Queue;

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

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;
}

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

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

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

	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;
	}
}

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;
}

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

int QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	int size = 0;
	while (cur)
	{
		++size;
		cur = cur->next;
	}
	return size;
}

typedef struct {
    Queue q;
} MyStack;


MyStack* myStackCreate() {
    MyStack* st = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&st->q);
    return st;
}

void myStackPush(MyStack* obj, int x) {
    QueuePush(&obj->q,x);
}

int myStackPop(MyStack* obj) {
    int size = QueueSize(&obj->q);
    while (size != 1)
    {
        QueuePush(&obj->q,QueueFront(&obj->q));
        QueuePop(&obj->q);
        size--;
    }
    int result = QueueFront(&obj->q);
    QueuePop(&obj->q);
    return result;
}

int myStackTop(MyStack* obj) {
    return QueueBack(&obj->q);
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q);
    free(obj);
}
CHAK&MING
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2144
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
数据结构—栈与队列的基本操作（c语言实现）
weixin_59799963的博客
03-28 3647
栈***1.思考******2.基本操作的实现******3.测试***4.思考 1.思考 1.1 为什么栈用数组来模拟比用链表来模拟更优一些？ 2.基本操作的实现 2.1 初始化栈 void StackInit(stack*ps) { assert(ps); ps->_a = (StackDate*)malloc(sizeof(StackDate) * 4); ps->_top = 0; ps->_capacity = 4; } 2.2 入栈 void StackPush(st
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
【数据结构】栈和队列的实现（C语言）
Lin_Alpaca的博客
11-17 2403
不看后悔的超详细的栈与队列的实现！！！！！！
数据结构之栈和队列C语言模拟实现
qq_65786321的博客
09-24 373
栈的特性是先进后出(FILO)。压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。出栈：栈的删除操作叫做出栈。出数据也在栈顶。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
C语言数据结构：栈和队列
qq_42319810的博客
07-02 1031
define MaxSzie 10 //定义栈中元素的最大个数//静态数组存放栈中元素int top;//栈顶指针}SqStack;//初始化栈S.top = -1;//初始化栈顶指针SqStack S;//声明一个顺序栈（分配空间）.....//判空操作else//数据域//指针域}*LiStack;//栈类型定义队列（Queue）是只允许在一端进行插入，在另一端删除的线性表重要术语：队头、队尾、空队列。
《数据结构C语言版》——栈和队列详解(图文并茂)，从零开始的学习
青春无问西东 岁月自成芳华
04-20 4617
一文搞懂数据结构系列之栈和队列部分，从0基础到快速手敲数据结构，小白也能轻松看懂的宝典！
数据结构栈和队列详解（C语言实现）
weixin_58666778的博客
11-22 1197
队列 栈
C语言栈和队列的实现
k666499436的博客
05-28 4731
详细讲解栈与队列的定义和特性，用C语言分别实现顺序栈、链栈、顺序(循环)队列、链队列，已经顺序存储与链式存储的区别
【数据结构|C语言版】栈和队列
2302_80269373的博客
05-09 1860
各位小伙伴大家好！上次小编给大家讲解了数据结构中的重要基础：算法效率和复杂度分析，接下来我们讲解一下栈和队列！【知识框架】以上就是小编对栈和队列的讲解。如果觉得小编讲的还可以，还请一键三连。互三必回！持续更新中~！
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
数据结构栈和队列C语言实现.pdf
09-30
数据结构栈和队列C语言实现.pdf
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构之栈和队列-思路清晰纯C
08-31
队列 循环队列 栈 内容学习于 https://www.bilibili.com/video/BV1W64y1z7jh?p=19&spm_id_from=pageDriver&vd_source=4d33bf4ac4499f2c0370694554a02fa5
C语言栈和队列代码实现
08-08
栈和队列是两种最基本且常用的数据结构，它们在算法设计和程序实现中扮演着重要角色。本篇文章将深入探讨C语言中栈和队列的代码实现，包括数组和链表两种实现方式。 栈（Stack）是一种后进先出（LIFO，Last In ...
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 633
递归算法，爬楼梯等解法
数据结构之顺序表
m0_73634434的博客
07-10 460
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。
数据结构第23节 线性搜索
最新发布
hummhumm的专栏
07-12 322
线性搜索（Linear Search），也称为顺序搜索，是最基本的搜索算法之一。它的工作原理是通过遍历数组或列表中的每一个元素，直到找到目标值为止，或者遍历完所有元素后确定目标值不存在于列表中。线性搜索的时间复杂度为O(n)，其中n是列表中元素的数量。这是因为最坏情况下，你可能需要检查列表中的每一个元素才能找到目标值或确定它不在列表中。
【排序 - 堆排序】
2302_80393814的博客
07-10 542
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
数据结构关于栈和队列(C++)
06-15
通过本章的学习，我们对栈和队列的定义、基本操作和应用有了更加深入的了解，这有助于我们在实际编程中更好地运用栈和队列这两种数据结构，写出更加高效、健壮的程序。同时，这也为我们深入学习其他数据结构，例如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值