栈和队列（数据结构）

最新推荐文章于 2024-10-05 15:32:05 发布
最新推荐文章于 2024-10-05 15:32:05 发布
阅读量449 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qi_sjq_/article/details/122901715
版权
本文详细介绍了数据结构中的栈和队列实现，包括顺序栈、链栈和循环队列。通过C++代码展示了它们的基本操作，如初始化、入栈、出栈、取栈顶/队头元素等。同时，提供了入栈、出栈和遍历的示例，帮助理解这些数据结构的工作原理。
摘要由CSDN通过智能技术生成

栈

在这里插入图片描述

1.顺序栈：

顺序栈操作包括：初始化、入栈、出栈、判断是否为空、求顺序栈长度、清空栈、销毁栈、取栈顶元素。

#include <iostream>
 
using namespace std;
 
#define MAX 100
 
//顺序栈的定义 
typedef struct 
{
	int *base;
	int *top;
	int stacksize;
}SqStack;
 
//初始化
int InitStack(SqStack &S) 
{
	S.base = new int[MAX]; // 为顺序栈动态分配一个最大容量为MAX的数组空间
	if (!S.base) 
	{
		return 0;
	}
	
	S.top = S.base;//初始化将栈置空，就是让头指针指向尾指针，从语句上讲就是把尾指针的值赋值给头指针 
	S.stacksize = MAX;
	
	return 1;
}
 
//入栈
int Push_S(SqStack &S, int e) 
{
	//将元素e入栈 
	if (S.top - S.base == S.stacksize) // 判断栈是否满 
	{
		return 0;
	}
	*S.top++ = e;   // *S.top=e;  S.top++;
	
	return 1;
}
 
//出栈
int Pop_S(SqStack &S, int &e) 
{
	//用e返回出栈的元素
	if (S.top == S.base) // 判断栈是否为空 
	{                
		return 0;
	}
	e = *--S.top;   // --S.top;e=*S.top;
	
	return 1;
}
 
// 取栈顶元素
int GetTop( SqStack S, int &e)  
{
	if (S.top == S.base)
		return 0; 	// 栈空
	
	e = *(S.top - 1);
	
	return 1;
}
 
int main()
{
	SqStack S;
 
	if (InitStack(S)) 
	{
		printf("顺序栈初始化成功!\n");
	}
	else 
	{
		printf("顺序栈初始化失败!\n");
	}
 
	int loop = 1;
	int e1;
	int i = 1;
	
	// 入栈
	printf("请输入入栈元素(输入0终止):\n");
	while (loop) 
	{
		printf("请输入第%d个元素值:",i++);
		scanf("%d", &e1);
		if (e1 != 0) 
		{
			Push_S(S,e1);
 
		}
		else if (e1 == 0) 
		{
			loop = 0;
		}
	}
 
	// 取栈顶元素
	int e2;
	GetTop(S, e2);
	printf("栈顶元素是:%d\n", e2);
 
	// 出栈
	int e3; int j = 1;
	while (S.top != S.base)
	{
		Pop_S(S, e3);
		printf("第%d个出栈的元素是:%d\n",j++,e3);
	}
	
	system("pause");
	
	return 0;
}

2.链栈：

操作包括：初始化、入栈、出栈、取栈顶元素。

#include <iostream>
 
using namespace std;
 
// 链栈的存储结构
typedef struct StackNode
{
    int data;
    struct StackNode *next;
}StackNode, *LinkStack;
 
// 初始化
int InitStack(LinkStack &S) 
{
	S = NULL;   // 将栈顶指针置空
	return 1;
}
 
// 入栈
int Push(LinkStack &S, int e)
{
	//元素e入栈
	StackNode *p;
	p = new StackNode;  // 生成新节点
	
	p->data = e;        // 将新节点数据域置为e
	p->next = S;        // 将新节点插入栈顶
	S = p;             // 修改栈顶指针
	return 1;         // 链栈要注意指针的方向是从栈顶指向栈底的 
}
 
// 出栈
int Pop(LinkStack &S, int &e)
{
	if (S == NULL)
	{
		return 0;    // 栈空
	}
	e = S->data;    //将栈顶元素赋值给e
	StackNode *p;
	p = S;         // 临时保存栈顶元素空间，准备释放
	S = S->next;    // 修改栈顶指针
	delete p;     // 释放原栈顶元素空间
	return 1;
}
 
// 取栈顶元素
int GetTop(LinkStack S)
{
	//返回S的栈顶元素,不修改栈顶指针
	if (S != NULL)  // 栈非空
		return S->data;  // 返回栈顶元素的值,栈顶指针不变
}
 
void TraveStack(LinkStack S) 
{
	StackNode *p;
	p = S;
	while (p) 
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
 
int main() 
{
	LinkStack S;
 
	if (InitStack(S)) 
	{
		printf("链栈初始化成功!\n");
	}
	else 
	{
		printf("链栈初始化失败!\n");
	}
 
	// 入栈
	int n;
	printf("请输入栈的元素个数:");
	scanf("%d",&n);
	for (int i = 0; i < n;)
	{
		int e;
		printf("请输入第%d个入栈的元素:",++i);
		scanf("%d", &e);
		Push(S, e);
	}
	printf("遍历栈:\n");
	TraveStack(S);
 
	// 出栈（取出两个元素）
	for (int i = 0; i < 2;)
	{
		int a;
		Pop(S, a);
		printf("第%d个出栈的元素:%d\n", ++i, a);
	}
	printf("遍历栈:\n");
	TraveStack(S);
	
	printf("栈顶元素是:%d\n", GetTop(S));
	
	system("pause");
	
	return 0;
}

队列

在这里插入图片描述
1.顺序队列

在队列中为解决“假溢出”问题，因此顺序队列常用循环队列表示，循环队列常见操作：初始化、求长度、入队、出队、取对头元素。

#include <iostream>
 
#define MAXQSIZE 100
 
using namespace std;
 
// 定义顺序队列
typedef struct 
{
	int *base;   //分配存储空间 
	int front;  //队头指针 
	int rear;  //队尾指针 
}SqQueue;
 
 
//初始化循环队列 
int InitQueue(SqQueue &Q) 
{
	Q.base = new int[MAXQSIZE];   //分配存储空间
	if (!Q.base) 
		return 0;     // 存储空间分配失败 
	Q.front = Q.rear = 0;
	
	return 1;
}
 
// 求队列的长度
int QueueLength(SqQueue Q)
{
	return ((Q.rear - Q.front) + MAXQSIZE) % MAXQSIZE;
}
 
 
// 入队操作
int EnQueue(SqQueue &Q, int e) 
{
	//首先判断队列是否已满
	if ((Q.rear + 1) % MAXQSIZE == Q.front) 
	{
		return 0;
	}
	Q.base[Q.rear] = e;  // 新元素插入队尾
	Q.rear = (Q.rear + 1) % MAXQSIZE;   // 队尾指针加1
	return 1;
}
 
//出队操作
 int DeQueue(SqQueue &Q, int &e) 
 {
	if (Q.front == Q.rear)
	{
		return 0;
	}
	e = Q.base[Q.front];  // 保存队头元素
	Q.front = (Q.front + 1) % MAXQSIZE;  // 队头指针加1
	
	return 1;
}
 
// 取队头元素
int GetHead(SqQueue Q)// 返回Q的队头元素, 不修改队头指针
 {
	 if (Q.front != Q.rear)   // 队列非空
		 return Q.base[Q.front];  // 返回队头元素的值,队头指针不变
 }
	 
//遍历队列
void TraveQueue(SqQueue Q) 
{
	int len = QueueLength(Q);
	for (int i = 0; i < len; i++) 
	{
		int e;
		DeQueue(Q, e);
		printf("%d ", e);
	}
}
 
int main() 
{
	SqQueue Q;
 
	if (InitQueue(Q)) 
	{
		printf("队列初始化成功!\n");
	}
	else 
	{
		printf("队列初始化失败!\n");
	}
	printf("队列的初始长度是:%d\n", QueueLength(Q));
 
	// 入队
	int n;
	printf("请输入队元素的个数:");
	scanf("%d", &n);
	for (int i = 0; i < n; i++) 
	{
		int e;
		printf("请输入第%d个元素的值:", i + 1);
		scanf("%d", &e);
		EnQueue(Q, e);
	}
	printf("队列的长度是:%d\n", QueueLength(Q));
	
	printf("遍历队列:");
	TraveQueue(Q);
 
	printf("\n队头元素:%d\n", GetHead(Q));
 
	// 出队
	for (int i = 0; i < 2; i++)
	{
		int e;
		DeQueue(Q, e);
		printf("第%d个出队元素的值:%d\n", i + 1, e);
	}
	
	system("pause");
	
	return 0;
}

2.链对：

通常用单链表示，常见操作为：初始化、入队、出队、取对头元素。

#include <iostream>
 
#define MAXQSIZE 100
 
using namespace std;
 
// 定义顺序队列
typedef struct 
{
	int *base;   //分配存储空间 
	int front;  //队头指针 
	int rear;  //队尾指针 
}SqQueue;
 
 
//初始化循环队列 
int InitQueue(SqQueue &Q) 
{
	Q.base = new int[MAXQSIZE];   //分配存储空间
	if (!Q.base) 
		return 0;     // 存储空间分配失败 
	Q.front = Q.rear = 0;
	
	return 1;
}
 
// 求队列的长度
int QueueLength(SqQueue Q)
{
	return ((Q.rear - Q.front) + MAXQSIZE) % MAXQSIZE;
}
 
 
// 入队操作
int EnQueue(SqQueue &Q, int e) 
{
	//首先判断队列是否已满
	if ((Q.rear + 1) % MAXQSIZE == Q.front) 
	{
		return 0;
	}
	Q.base[Q.rear] = e;  // 新元素插入队尾
	Q.rear = (Q.rear + 1) % MAXQSIZE;   // 队尾指针加1
	return 1;
}
 
//出队操作
 int DeQueue(SqQueue &Q, int &e) 
 {
	if (Q.front == Q.rear)
	{
		return 0;
	}
	e = Q.base[Q.front];  // 保存队头元素
	Q.front = (Q.front + 1) % MAXQSIZE;  // 队头指针加1
	
	return 1;
}
 
// 取队头元素
int GetHead(SqQueue Q)// 返回Q的队头元素, 不修改队头指针
 {
	 if (Q.front != Q.rear)   // 队列非空
		 return Q.base[Q.front];  // 返回队头元素的值,队头指针不变
 }
	 
//遍历队列
void TraveQueue(SqQueue Q) 
{
	int len = QueueLength(Q);
	for (int i = 0; i < len; i++) 
	{
		int e;
		DeQueue(Q, e);
		printf("%d ", e);
	}
}
 
int main() 
{
	SqQueue Q;
 
	if (InitQueue(Q)) 
	{
		printf("队列初始化成功!\n");
	}
	else 
	{
		printf("队列初始化失败!\n");
	}
	printf("队列的初始长度是:%d\n", QueueLength(Q));
 
	// 入队
	int n;
	printf("请输入队元素的个数:");
	scanf("%d", &n);
	for (int i = 0; i < n; i++) 
	{
		int e;
		printf("请输入第%d个元素的值:", i + 1);
		scanf("%d", &e);
		EnQueue(Q, e);
	}
	printf("队列的长度是:%d\n", QueueLength(Q));
	
	printf("遍历队列:");
	TraveQueue(Q);
 
	printf("\n队头元素:%d\n", GetHead(Q));
 
	// 出队
	for (int i = 0; i < 2; i++)
	{
		int e;
		DeQueue(Q, e);
		printf("第%d个出队元素的值:%d\n", i + 1, e);
	}
	printf("队列的长度是:%d\n", QueueLength(Q));
	
	system("pause");
	
	return 0;
}

在这里插入图片描述
参考：
https://blog.csdn.net/qq_22847457/article/details/94351307
https://blog.csdn.net/qq_22847457/article/details/94555573
https://blog.csdn.net/qq_22847457/article/details/94545627
https://blog.csdn.net/qq_22847457/article/details/94379784
https://blog.csdn.net/qq_22847457/article/details/94354768

暮w光
关注
专栏目录
数据结构——栈与队列
m0_57484470的博客
10-17 6488
数据结构栈与队列相关基础知识详解！！！
Java模拟栈和队列数据结构的基本示例讲解共4页.pdf
10-30
本篇文档《Java模拟栈和队列数据结构的基本示例讲解共4页.pdf》将深入浅出地介绍如何在Java中实现栈和队列，以帮助开发者更好地理解和应用这些概念。 首先，让我们来了解栈和队列的基本特性： 1. **栈（Stack）**...
【数据结构】栈和队列
小羊的博客
07-12 2606
栈超超超详解
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 24万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
Java数据结构之栈和队列
fear_wolf的博客
10-24 1393
我们可以从集合那一节的图中看出，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。我们可以采用头插法来入栈，每次出栈时删除的也是头节点，时间复杂度也是O（1），但仍没有顺序栈方便，毕竟顺序栈不用修改指向。：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有。，队不为空时，rear都是front之后，随着入队出队的操作，最终。：栈的插入操作，叫做进栈/压栈/入栈，入数据在栈顶。
栈和队列的数据结构
a8687216的博客
09-06 1344
使用链表实现栈和队列的操作，可以充分发挥链表动态分配内存的特性，避免数组实现中需要预定义大小的限制。也就是说，最后加入栈中的元素最先被移除。这样插入操作发生在队尾，删除操作发生在队头。即最先加入队列的元素最先被移除。作为栈的栈顶，实现入栈、出栈和查看栈顶的操作。的原则，因此我们可以使用单向链表的。的原则，因此使用链表实现时，可以让。
数据结构与算法——栈和队列定义和特点
weixin_68773927的博客
10-27 3960
栈（stack）是一个特殊的线性表是限定仅在一端（通常是尾部）运行插入和删除操作的线性表又称为先进先出的线性表简称 LIFO 结构 9（Last In First out）
数据结构（栈和队列）
会思想的苇草i的博客
02-13 2060
栈( stack）是限定仅在表尾进行插人或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶( top )，相应地，表头端称为栈底（ bottom )。不含元素的空表称为空栈。后进先出( Last In First Out，LIFO）。栈( stack）是限定仅在表尾进行插人或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶( top )，相应地，表头端称为栈底（ bottom )。不含元素的空表称为空栈。后进先出( Last In First Out，LIFO）
数据结构----栈和队列
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
05-19 1867
栈篇 1.1栈 栈，线性表的一种特殊的存储结构。与学习过的线性表的不同之处在于栈只能从表的固定一端对数据进行插入和删除操作，另一端是封死的。由于栈只有一边开口存取数据，称开口的那一端为“栈顶”，封死的那一端为“栈底”（类似于盛水的木桶，从哪进去的最后还得从哪出来）。 1.2.栈操作数据元素的两种动作： 数据元素用栈的数据结构存储起来，称为“入栈”，也叫“压栈”。 数据元素由于某种原因需要从栈结构中提取出来，称为“出栈”，也叫“弹栈”。 注意：栈遵循先进后出原则 1.3.栈的表示方式 既然栈
Matlab实现支持代码生成的栈和队列数据结构
anbuqi的博客
07-13 1077
matlab没有内置的队列和栈数据结构，本文介绍一种使用Matlba函数和coder.varsize实现存储结构体的队列和栈方法，支持代码生成转成C语言或mex。%CREATEVT 预创建结构体，方便代码生成% 此处显示详细说明vt=struct;vt.x=0;vt.y=0;vt.z=0;end。
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
Java模拟栈和队列数据结构的基本示例讲解
09-02
Java中的栈和队列是两种基本的数据结构，它们在编程中有着广泛的应用。栈（Stack）遵循“后进先出”（Last In First Out, LIFO）原则，而队列（Queue）则遵循“先进先出”（First In First Out, FIFO）原则。 栈的...
栈和队列数据结构教程PPT学习教案.pptx
10-08
**栈和队列数据结构详解** 栈和队列是计算机科学中最基础且重要的两种线性数据结构，它们在算法设计和程序实现中扮演着至关重要的角色。本教程将深入讲解这两种数据结构及其应用。 **3.1 栈** 栈是一种特殊的...
栈和队列数据结构的基本概念及其相关的Python实现
09-21
栈和队列是两种基本但极其重要的数据结构，在计算机科学中有着广泛的应用。它们都是线性数据结构，意味着数据元素之间存在一对一的关系，但它们在插入和删除操作上有着本质的区别。 栈（Stack）被称为“后进先出”...
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 393
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 345
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1107
本文介绍了数据结构中的AVL树，给出了C++的代码实现
【笔记】数据结构12
m0_52024881的博客
09-29 513
看到的社区的一个知识总结，这里记录一下。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 360
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
Java实现栈和队列数据结构
"Java语言实现的栈和队列数据结构示例代码" 在这个Java代码示例中，我们有两个类：`Node` 和 `SqStack`。`Node` 类用于构建链表，代表了栈或队列中的元素节点，而 `SqStack` 类实现了基于数组的栈操作。 首先，`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值