实现简单的栈与队列

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

前言：前面已经详细地介绍了基本的顺序表和链表，这次要介绍的是数据结构中的栈与队列。从本质上来说，二者是特殊的线性表，是依赖于顺序表或链表来实现的，所以只要能够很好地掌握顺序表和链表，再了解清楚栈与队列的概念及基本结构，就可以很好地将二者实现出来。

注：由上言以及下文可以知道栈与队列的实现与顺序表，链表的实现大同小异（甚至更简单），一些内容不会详细说明，不清楚的可以再看看以下两篇文章：

（1）顺序表的实现

（2）单链表的实现

目录：

一：栈

1. 栈的概念

2. 栈的结构(图示)

3. 栈的重要接口函数

4. 栈实现相关代码总览

二：队列

1. 队列的概念

2. 队列的结构(图示)

3. 队列的重要接口函数

4. 队列实现相关代码总览

一：栈

1. 栈的概念

(1) 栈: 一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。 进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。 栈中的数据元素遵守 后进先出 的原则。
(2) 压栈： 栈的插入操作叫做压栈/进栈 /入栈，即入数据在栈顶 。
(3) 出栈： 栈的删除操作叫做出栈。即 出数据也在栈顶 。

2. 栈的结构(图示)

注：栈一定要遵守先进后出的原则。

3. 栈的重要接口函数

我们可以使用顺序表来实现栈，也可以用链表实现栈，但是链表实现栈有两种方式，一种是头插头删，一种是尾插尾删。而单链表进行尾插尾删时要进行的找尾操作较为复杂(要遍历链表)，所以我们选择顺序表(数组)来实现栈，其结构相对链表而言较为优势。

栈相关的七个重要接口函数：

void StackInit(ST* st);//初始化
void StackPush(ST* st, STDataType x);//入栈
void StackPop(ST* st);//出栈
STDataType StackTop(ST* st);//获取栈顶元素
int StackSize(ST* st);//获取栈中的有效元素个数
bool StackEmpty(ST* st);//判断栈是否为空
void StackDestroy(ST* st);//销毁栈

4. 栈实现相关代码总览

（1）TestStack.c

#define _CRT_SECURE_NO_WARNINGS
#include "Stack.h"

void TestStack1()
{
	ST st;//定义一个栈
	StackInit(&st);//将栈初始化,要传递结构体指针才能在接口函数内对其进行改变

	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);//压栈
	
	printf("%d\n", StackSize(&st));//打印此时的栈内元素个数
	
	while (!StackEmpty(&st))//打印出栈内的所有数据
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}//一个小疑问：Pop执行后的终点是top=0,但是此时st->a[0]不是等于1吗,这样不是没有删干净吗？
	printf("\n%d\n", StackSize(&st));
	StackDestroy(&st);
}

void TestStack2()
{
	ST st;//定义一个栈
	StackInit(&st);//将栈初始化,要传递结构体指针才能在接口函数内对其进行改变

	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	printf("%d\n", StackSize(&st));
	StackPop(&st);
	StackPop(&st);
	printf("%d\n", StackSize(&st));//Pop两次后栈内的元素个数
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	printf("\n%d\n", StackSize(&st));
	StackDestroy(&st);
}

int main()
{
	TestStack1();
	//TestStack2();
	return 0;
}

（2）Stack.h

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

typedef int STDataType;

//定义一个动态增长的数组栈
typedef struct Stack
{
	STDataType* a;//指针a指向动态开辟的数组
	int top;//表示栈内的有效元素个数
	int capacity;//表示栈的空间容量
} ST;

//相关接口函数的定义
void StackInit(ST* st);//初始化
void StackPush(ST* st, STDataType x);//入栈
void StackPop(ST* st);//出栈
STDataType StackTop(ST* st);//获取栈顶元素
int StackSize(ST* st);//获取栈中的有效元素个数
bool StackEmpty(ST* st);//判断栈是否为空
void StackDestroy(ST* st);//销毁栈

（3）Stack.c

#define _CRT_SECURE_NO_WARNINGS
#include "Stack.h"

void StackInit(ST* st)
{
	assert(st);
	st->a = NULL;
	//top初始化为0时,top指向的是栈顶的下一个数据,因为压栈是先插入数据后top再加1
	st->top = st->capacity = 0;
}

void StackPush(ST* st, STDataType x)//入栈,向栈内插入数据
{
	assert(st);
	if (st->top == st->capacity)//判断容量是否足够,不够就扩容
	{
		int newCapacity = st->capacity == 0 ? 4 : st->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(st->a, sizeof(ST) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		st->a = tmp;
		st->capacity = newCapacity;
	}
	st->a[st->top] = x;
	st->top++;//先插入数据,top再++,即top此时指向的是栈顶的下一个数据
}

void StackPop(ST* st)//出栈
{
	assert(st);
	//assert(st->top > 0);
	assert(!StackEmpty(st));//栈不能为空
	st->top--;
}

bool StackEmpty(ST* st)//判断栈是否为空
{
	assert(st);
	return st->top == 0;
}

STDataType StackTop(ST* st)//获取栈顶元素
{
	assert(st);
	return st->a[st->top - 1];//top下标指向的是栈顶的后一个数据
}

int StackSize(ST* st)//获取栈内有效数据的个数
{
	assert(st);
	return st->top;
}

void StackDestroy(ST* st)//销毁栈
{
	assert(st);
	while (!StackEmpty(st))
	{
		StackPop(st);
	}
	st->a = NULL;
	st->top = st->capacity = 0;
}

二：队列

1. 队列的概念

队列： 只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的特性。
入队列： 进行插入操作的一端称为 队尾。
出队列： 进行删除操作的一端称为 队头。

2. 队列的结构(图示)

 注：队列一定要遵守先进先出的原则。

3. 队列的重要接口函数的实现

与栈相同，队列既可以通过顺序表来实现，也可以通过链表实现。但与栈实现起来不同的是，对于队列而言，链表的结构更适合它，因为队列主要涉及到的是头部尾部的插入与删除，而顺序表(数组)实现起来的效率会更低一些。

这里需要特别说明的是：选用的是单链表，并且我们需要给这个单链表定义好头节点 (head)和尾节点(tail)，将它们作为队列的基本框架，以形成一个较好头插尾删的单链表。

图示：

代码说明：

队列相关接口函数：

void QueueInit(Queue* pq);//初始化队列
void QueuePush(Queue* pq, QDataType x);//入队列
void QueuePop(Queue* pq);//出队列
bool QueueEmpty(Queue* pq);//判断队列是否为空
int QueueSize(Queue* pq);//返回队列中有效数个数
QDataType QueueFront(Queue* pq);//获取队头数据
QDataType QueueBack(Queue* pq);//获取队尾数据
void QueuePrint(Queue* pq);//打印队列(同时会清空队列的元素)
void QueueDestroy(Queue* pq);//销毁队列中动态开辟节点的链表

4. 队列实现相关代码总览

(1) TestQueue.c

#define _CRT_SECURE_NO_WARNINGS
#include "Queue.h"

void TestQueue1()
{
	Queue q;
	QueueInit(&q);

	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	printf("%d\n", QueueSize(&q));//打印此时队列内的元素个数

	QueuePop(&q);
	QueuePop(&q);
	printf("%d\n", QueueSize(&q));//打印此时队列内的元素个数
	QueuePrint(&q);//QueuePrint函数调用的同时会清空队列
	printf("\n%d\n", QueueSize(&q));
	QueueDestroy(&q);
}

void TestQueue2()
{
	Queue q;
	QueueInit(&q);

	QueuePush(&q, 5);
	QueuePush(&q, 6);
	QueuePush(&q, 7);
	QueuePush(&q, 8);
	//打印此时队列元素个数,队头数据,对尾数据
	printf("%d %d %d\n", QueueSize(&q), QueueFront(&q), QueueBack(&q));

	QueuePrint(&q);//QueuePrint函数调用的同时会清空队列
	printf("\n%d\n", QueueSize(&q));
	QueueDestroy(&q);
}

int main()//各个接口函数功能的测试
{
	TestQueue1();
	//TestQueue2();
	return 0;
}

(2) Queue.h

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

typedef int QDataType;

//用单链表实现队列(定义队列中的链表结构)
typedef struct QueueListNode
{
	struct QueueListNode* next;//指针域
	QDataType data;//数据域
} QLNode;

//为了更好地实现单链表的头删(出队列)与尾插(入队列),在队列的链表结构中在定义一个头节点与尾节点,可以表示队列的结构
typedef struct Queue
{
	QLNode* head;
	QLNode* tail;
} Queue;

//队列相关接口函数的定义
void QueueInit(Queue* pq);//初始化队列
void QueuePush(Queue* pq, QDataType x);//入队列
void QueuePop(Queue* pq);//出队列
bool QueueEmpty(Queue* pq);//判断队列是否为空
int QueueSize(Queue* pq);//返回队列中有效数个数
QDataType QueueFront(Queue* pq);//获取队头数据
QDataType QueueBack(Queue* pq);//获取队尾数据
void QueuePrint(Queue* pq);//打印队列(同时会清空队列的元素)
void QueueDestroy(Queue* pq);//销毁队列中动态开辟节点的链表

(3) Queue.c

#define _CRT_SECURE_NO_WARNINGS
#include "Queue.h"

void QueueInit(Queue* pq)//队列初始化
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
}

void QueuePrint(Queue* pq)//打印整个队列的元素(同时会清空队列的元素)
{
	assert(pq);
	while (!QueueEmpty(pq))
	{
		printf("%d ", QueueFront(pq));
		QueuePop(pq);//只有清理了对头元素,才可以继续向后读取数据
	}
}

void QueuePush(Queue* pq, QDataType x)//入队列(单链表的尾插)
{
	QLNode* newnode = (QLNode*)malloc(sizeof(QLNode));//开辟新节点
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->data = x;
	//节点入列的两种情况
	if (pq->head == NULL)//1.原队列为空
	{
		pq->head = pq->tail = newnode;
		newnode->next = NULL;
	}
	else//原队列不为空
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
		pq->tail->next = NULL;
	}
}

void QueuePop(Queue* pq)//出队列,单链表的头删
{
	assert(pq);
	assert(!QueueEmpty(pq));//删除时队列不能为空
	QLNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
}

bool QueueEmpty(Queue* pq)//判断队列是否为空
{
	assert(pq);
	return pq->head == NULL;
}

int QueueSize(Queue* pq)//返回队列中有效数个数
{
	assert(pq);
	QLNode* cur = pq->head;
	int num = 0;
	while (cur)//遍历队列中的单链表
	{
		num++;
		cur = cur->next;
	}
	return num;
}

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

void QueueDestroy(Queue* pq)//销毁队列中动态开辟节点的链表
{
	assert(pq);
	while (pq->head)
	{
		QLNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}

总结：

栈与队列的实现最重要的是结构以及对链表，顺序表的理解程度，这里再强调一次：数据结构的学习中结构的理解十分重要，所以我们可以多画画相关的图，再结合图理解这样一定可以事半功倍。栈与队列的介绍就到这里结束，谢谢大家的阅读，再见。

RED MOON LEGENDS
关注
专栏目录
栈与队列的实现及其应用场景
一键难忘的博客
05-23 1414
栈和队列作为常见的数据结构，在计算机科学中发挥着重要的作用。它们不仅在算法和数据处理中有着广泛的应用，而且在实际的软件开发中也有着丰富的场景。通过深入理解栈和队列的原理和应用，可以帮助我们更好地设计和优化程序，提高代码的效率和可维护性。
如何使用JavaScript实现栈与队列
10-16
在JavaScript中，可以使用数组来简单实现队列： ```javascript function Queue() { this.items = []; } Queue.prototype.enqueue = function(item) { this.items.push(item); }; Queue.prototype.dequeue = ...
栈实现队列 与 队列实现栈
bury_pen
03-10 300
文章目录队列实现栈思路代码实现栈实现队列思路代码实现 队列实现栈 思路 假设我们有队列A和队列B，如何实现一个栈呢？ 也就是说，给我们两个队列，依次push 1 2 3 4，如下图，如何让弹出的顺序是 4 3 2 1呢？ 思路很简单，如下图，我们把队列A中的前(n-1)个元素pop，并push到队列B中，再弹出队列A中的元素。 然后，交换队列A和B，继续进行上述操作，直至两个队列均为空。 代...
数组实现 栈 和队列
我思故我在
10-26 249
package 算法; /** * 数组实现 */ public class test3 { /** * 数组实现 栈 */ public static class ArrStack{ public int size = 0; public int capacity = 0; public int[] arr =null; //初始化栈容量 public ArrStack(int .
第二章 栈与队列（Python实现版）
qq_40467656的博客
08-24 1075
官方定义：栈是限定仅在表尾进行插入和删除操作的线性表；解释：栈也是一种线性结构，相比数组， 栈对应的操作是数组的子集，只能从一端添加元素，也只能从一端取出元素。把允许删除和插入的一端称为栈顶（top），另一端称为栈底（bottom栈是一种后进先出的数据结构：Last In First Out (LIFO)思考：最先进栈的元素，是不是就只能是最后出栈？不一定，但是依然要满足只能从栈顶进出。队列是一种先进先出的数据结构（先到先得）：First in first out（FIFO）
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 24万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
十分钟手撕栈与队列——栈与队列实现详解
qq_61500888的博客
03-27 2805
十分钟带你一命通关栈与队列 既然选择远方，只顾风雨兼程！
用JavaScript实现栈与队列
竹杖芒鞋轻胜马，谁怕？一蓑烟雨任平生
04-30 549
栈和队列是web开发中最常用的两种数据结构。绝大多数用户，甚至包括web开发人员，都不知道这个惊人的事实。如果你是一个程序员，那么请听我讲两个启发性的例子:使用堆栈来组织数据，来实现文本编辑器的“撤消”操作;使用队列处理数据，实现web浏览器的事件循环处理事件(单击click、悬停hoover等)。 等等，先想象一下我们作为用户和程序员，每天使用栈和队列的次数，这太惊人了吧！由于它们在设计上有普遍性和相似性，我决定从这里开始为大家介绍数据结构。 栈 在计算机科学中，栈是一种线性数据结构。如果你理解起来有困
简单的用栈实现队列
zz_smallred的博客
08-11 325
简单的用栈实现队列 队列是一种先进先出的数据结构，栈是一种先进后出的数据结构，形象一点就是这样： 在面试中常常会问到这样一个问题：怎么使用栈来实现一个队列？如何用队列来实现一个栈？ 前者问的较多，后者问的较少，但掌握得多也不是坏事嘛，接下来我们就来解析下这两个问题。 用栈实现队列 首先，队列的 API 如下： class MyQueue { /** 添加元素到队尾 */ public void push(int x); /** 删除队头的元素并返回 */ public
栈与队列学习总结
guoquanqin的博客
03-20 6137
栈与队列学习总结 栈 结构特点：后进者先出，先进者后出，同时栈是一种“操作受限”的线性表，只允许在一端插入和删除数据 栈既可以用数组来实现，也可以用链表来实现。用数组实现的栈，我们叫作顺序栈，用链表实现的栈，我们叫作链式栈。 时间空间复杂度分析 在入栈和出栈过程中，只需要一两个临时变量存储空间，所以空间复杂度是 O(1)。 不管是顺序栈还是链式栈，入栈、出栈只涉及栈顶个别数据的操作，所以时间复杂度都是 O(1)。 特殊情况： 对于出栈操作来说，不会涉及内存的重新申请和数据的搬移，所以出.
使用栈实现队列
weixin_48276298的博客
05-15 1859
题目介绍 力扣232题：https://leetcode-cn.com/problems/implement-queue-using-stacks/ 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）： 实现 MyQueue 类： void push(int x) 将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek() 返回队列开头的元素 boolean empty() 如果队列为空，返回 true ；否
Python实现栈和队列的简单操作方法示例
09-18
以下是一个简单的栈实现： ```python class Stack: def __init__(self): self.stack = [] def push(self, value): self.stack.append(value) def pop(self): if self.stack: return self.stack.pop() ...
JS实现利用两个队列表示一个栈的方法
11-27
4. 要显示栈中的元素，可以简单地显示队列的内容。 ```javascript this.display = function() { console.log(arr); } ``` 通过这种方法，我们可以利用两个队列的优势，实现栈的基本功能。虽然这不是最直接或效率...
JavaScript基于数组实现的栈与队列操作示例
10-17
JavaScript中的栈与队列是两种不同的数据结构，它们在执行操作时有着截然不同的方式。栈（Stack）是一种遵循后进先出（LIFO）原则的数据结构，而队列（Queue）则是一种遵循先进先出（FIFO）原则的数据结构。在...
C++数据结构实验_实现共享栈，链栈，循环队列，链队列
12-07
在C++中，循环队列通常用数组实现，通过两个指针分别指向队头和队尾，队列的入队（enqueue）和出队（dequeue）操作可以通过简单的指针移动来完成，避免了数组扩容的开销。 最后，我们讨论链队列。链队列是基于链表...
数据结构2——单链表
最新发布
weixin_73629886的博客
09-23 1148
了解了顺序表的不足，下面我们就来学习一下链表，看一看链表能不能解决顺序表的不足。
数据结构：二叉树（2）
2303_78940834的博客
09-21 1277
普通的树的实用价值比较小，将树更一步特殊化成二叉树，将获得更多的特殊性质。例如搜索二叉树，红黑树等。这篇博文主要介绍二叉树的基础知识，进阶版高级二叉树，后续会持续更新。
【数据结构取经之路】图解红黑树
bit_pan的博客
09-20 865
AVL-tree之外，另一个颇具历史且被广泛使用的平衡二叉搜索树是红黑树(RB-tree)，这名字听起来除了很抽象外，还颇具大哥味哈，会不会很难？客观地说，难度是有的，下面我们细细道来。//结点的颜色//红黑树结点的定义//结点的左孩子//结点的右孩子//结点的父节点//结点的颜色T _data;//结点的数据域{}以上就是红黑树节点定义，但有两个问题：为什么需要指向父节点的指针？为什么要将结点的默认颜色设置成黑色？先来回答第一个问题，在旋转时需要访问父节点，所以引入了指向父节点的指针。
代码随想录算法训练营 | 二叉树理论基础
jiabao0520的博客
09-22 537
训练营：二叉树理论基础
C#代码实现栈与队列数据结构
本资源是一份关于C#编程的文档，涉及的主要内容是“停车场设计与实现”的基础概念，包括类的定义和数据结构的使用。文档的核心部分展示了两个主要的数据结构：栈（Stack）和队列（Queue），它们在计算机科学中常用于...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值