数据结构 栈与队列

最新推荐文章于 2022-10-17 22:50:15 发布
最新推荐文章于 2022-10-17 22:50:15 发布
阅读量280 收藏
点赞数
分类专栏： # 数据结构 文章标签： 数据结构 栈与队列 栈 栈与队列算法实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30757161/article/details/80385127
版权 
1. 采用链式存储实现栈的初始化、入栈、出栈操作。
存储结构：
typedef int Status;
typedef int SElemType;
typedef struct SNode{
	SElemType data;
	struct SNode *next;
}SNode,*LinkStack;
程序：
#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef int SElemType;
typedef struct SNode{
	SElemType data;
	struct SNode *next;
}SNode,*LinkStack;
//链栈的初始化
Status InitStack (LinkStack &S)
{
      S=NULL;
      return OK;
}
//　链栈的入栈
Status Push(LinkStack &S , SElemType e)
{
	SNode *p = new SNode;
	if(!p)
	{
		return OVERFLOW;
	}
	p->data = e;
	p->next = S;
	S = p;
	return OK;
}
//链栈的出栈
Status Pop (LinkStack &S,SElemType & e)
{
	SNode *p;
		if(!S)
			return ERROR;
		e = S->data;
		p = S;
		S = S->next;
		delete p;
		return OK;
}
int main()
{
	LinkStack s;
	SElemType e;
	cout<<"进栈元素依次为："<<endl;
	if(InitStack(s)==OK)
		for(int j=1;j<=25;j++)
		{
			Push(s,j);
			cout<<j<<"  ";
		}
	cout<<endl<<"依次弹出的栈顶元素为："<<endl;
	while(Pop(s,e) == OK)
	{
		cout<<e<<"  ";
	}
	return 0;
}
实验结果：
2. 采用链式存储实现栈的初始化、入栈、出栈操作。
存储结构：
typedef int Status;
typedef int SElemType;
typedef struct{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;
程序；
#include<iostream>
#include<stdlib.h>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE  100
typedef int Status;
typedef int SElemType;
typedef struct{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;
//顺序栈的初始化
Status InitStack(SqStack &S)
{
	S.base = new SElemType[MAXSIZE];
	if(!S.base)
		exit (OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
//顺序栈的入栈
Status Push(SqStack &S,SElemType &e)
{
	if(S.top-S.base==S.stacksize)
		return ERROR;
	*(S.top++) = e;	//元素e压入栈顶，栈顶指针加1
	return OK;
}
//顺序栈的出栈
Status Pop(SqStack &S,SElemType &e)
{
	if(S.base == S.top)
		return ERROR;
	e = *(--S.top); //栈顶指针减1，将栈顶元素赋给e
	return OK;
}
int main()
{
	SqStack s;
	SElemType e;
	SElemType t;
	cout<<"进栈元素依次为："<<endl;
	if(InitStack(s)==OK)
		for(int j=1;j<=12;j++)
		{
			Push(s,j);
			cout<<j<<" ";
		}
	cout<<endl<<"依次弹出的栈顶元素为："<<endl;
	while(s.base!=s.top)
	{
		Pop(s,t);
		cout<<t<<" ";
	}
	return 0;
}
实验结果：
3. 采用链式存储实现队列的初始化、入队、出队操作。
存储结构：
typedef int QElemType;
typedef int Status;
typedef struct QNode{
	QElemType data;
	QNode *next;
}QNode,*QueuePtr;
typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;
程序：
#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int QElemType;
typedef int Status;
typedef struct QNode{
	QElemType data;
	QNode *next;
}QNode,*QueuePtr;
typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

//链队的初始化
Status InitQueue(LinkQueue &Q)
{
	Q.front = new QNode;
	if(Q.front == NULL)
	{
		return OVERFLOW;
	}
	Q.front->next = NULL;
	Q.rear = Q.front;
	return OK;
}
//链队的入队
Status EnQueue(LinkQueue &Q,QElemType e)
{
	QNode *p = new QNode;
	if(p == NULL)
	{
		return OVERFLOW;
	}
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;	// 修改队尾指针
	return OK;
}
//链队的出队
Status DeQueue(LinkQueue &Q,QElemType &e)
{
	if(Q.front == Q.rear)
	{
		return ERROR;
	}
	QNode *p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if(Q.rear == p)
	{
		Q.rear = Q.front;
	}
	delete p;
	return OK;
}
int main()
{
	LinkQueue Q;
	QElemType e;
	cout<<"进链队的元素依次为："<<endl;
	if(InitQueue(Q)==OK)
		for(int j=1;j<=30;j++)
		{
			EnQueue(Q,j);
			cout<<j<<" ";
		}
	cout<<endl<<"依次出链队的元素为："<<endl;
	while(DeQueue(Q,e) == OK)
	{
		cout<<e<<" ";
	}
	return 0;
}
实验结果：
4．采用顺序存储实现循环队列的初始化、入队、出队操作。
存储结构：
typedef int QElemType;
typedef int Status;
typedef struct{
	QElemType *base;
	int front;      //头指针
	int rear;       //尾指针
}SqQueue;
程序：
#include<iostream>
using namespace std;
#define MAXQSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int QElemType;
typedef int Status;
typedef struct{
	QElemType *base;
	int front;      //头指针
	int rear;       //尾指针
}SqQueue;
//循环队列的初始化
Status InitQueue(SqQueue &Q)
{
	Q.base = new QElemType[MAXQSIZE];
	if(!Q.base)
	{
		return OVERFLOW;
	}
	Q.front = Q.rear=0;
	return OK;
}
//循环队列的入队
Status EnQueue(SqQueue &Q,QElemType e)
{
	if((Q.rear+1)%MAXQSIZE == Q.front)
	{
		return ERROR;//队列满
	}
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear+1)%MAXQSIZE;
	return OK;
}
//循环队列的出队
Status DeQueue(SqQueue &Q,QElemType &e)
{
	if(Q.rear == Q.front)
	{
		return ERROR;
	}
	e = Q.base[Q.front];
	Q.front = (Q.front+1)%MAXQSIZE;
	return OK;
}
int main()
{
	SqQueue Q;
	QElemType e;
	cout<<"进循环队列的元素依次为："<<endl;
	if(InitQueue(Q)==OK)
		for(int j=1;j<=18;j++)
		{
			EnQueue(Q,j);
			cout<<j<<" ";
		}
	cout<<endl<<"依次出队的元素为："<<endl;
	while(Q.rear != Q.front)
	{
		DeQueue(Q,e);
		cout<<e<<" ";
	}
	return 0;
}
实验结果：

存储结构：
typedef int Status;
typedef int SElemType;
typedef struct SNode{
	SElemType data;
	struct SNode *next;
}SNode,*LinkStack;
程序：
#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef int SElemType;
typedef struct SNode{
	SElemType data;
	struct SNode *next;
}SNode,*LinkStack;
//链栈的初始化
Status InitStack (LinkStack &S)
{
      S=NULL;
      return OK;
}
//　链栈的入栈
Status Push(LinkStack &S , SElemType e)
{
	SNode *p = new SNode;
	if(!p)
	{
		return OVERFLOW;
	}
	p->data = e;
	p->next = S;
	S = p;
	return OK;
}
//链栈的出栈
Status Pop (LinkStack &S,SElemType & e)
{
	SNode *p;
		if(!S)
			return ERROR;
		e = S->data;
		p = S;
		S = S->next;
		delete p;
		return OK;
}
int main()
{
	LinkStack s;
	SElemType e;
	cout<<"进栈元素依次为："<<endl;
	if(InitStack(s)==OK)
		for(int j=1;j<=25;j++)
		{
			Push(s,j);
			cout<<j<<"  ";
		}
	cout<<endl<<"依次弹出的栈顶元素为："<<endl;
	while(Pop(s,e) == OK)
	{
		cout<<e<<"  ";
	}
	return 0;
}
实验结果：
2. 采用链式存储实现栈的初始化、入栈、出栈操作。
存储结构：
typedef int Status;
typedef int SElemType;
typedef struct{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;
程序；
#include<iostream>
#include<stdlib.h>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE  100
typedef int Status;
typedef int SElemType;
typedef struct{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;
//顺序栈的初始化
Status InitStack(SqStack &S)
{
	S.base = new SElemType[MAXSIZE];
	if(!S.base)
		exit (OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
//顺序栈的入栈
Status Push(SqStack &S,SElemType &e)
{
	if(S.top-S.base==S.stacksize)
		return ERROR;
	*(S.top++) = e;	//元素e压入栈顶，栈顶指针加1
	return OK;
}
//顺序栈的出栈
Status Pop(SqStack &S,SElemType &e)
{
	if(S.base == S.top)
		return ERROR;
	e = *(--S.top); //栈顶指针减1，将栈顶元素赋给e
	return OK;
}
int main()
{
	SqStack s;
	SElemType e;
	SElemType t;
	cout<<"进栈元素依次为："<<endl;
	if(InitStack(s)==OK)
		for(int j=1;j<=12;j++)
		{
			Push(s,j);
			cout<<j<<" ";
		}
	cout<<endl<<"依次弹出的栈顶元素为："<<endl;
	while(s.base!=s.top)
	{
		Pop(s,t);
		cout<<t<<" ";
	}
	return 0;
}
实验结果：
3. 采用链式存储实现队列的初始化、入队、出队操作。
存储结构：
typedef int QElemType;
typedef int Status;
typedef struct QNode{
	QElemType data;
	QNode *next;
}QNode,*QueuePtr;
typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;
程序：
#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int QElemType;
typedef int Status;
typedef struct QNode{
	QElemType data;
	QNode *next;
}QNode,*QueuePtr;
typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

//链队的初始化
Status InitQueue(LinkQueue &Q)
{
	Q.front = new QNode;
	if(Q.front == NULL)
	{
		return OVERFLOW;
	}
	Q.front->next = NULL;
	Q.rear = Q.front;
	return OK;
}
//链队的入队
Status EnQueue(LinkQueue &Q,QElemType e)
{
	QNode *p = new QNode;
	if(p == NULL)
	{
		return OVERFLOW;
	}
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;	// 修改队尾指针
	return OK;
}
//链队的出队
Status DeQueue(LinkQueue &Q,QElemType &e)
{
	if(Q.front == Q.rear)
	{
		return ERROR;
	}
	QNode *p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if(Q.rear == p)
	{
		Q.rear = Q.front;
	}
	delete p;
	return OK;
}
int main()
{
	LinkQueue Q;
	QElemType e;
	cout<<"进链队的元素依次为："<<endl;
	if(InitQueue(Q)==OK)
		for(int j=1;j<=30;j++)
		{
			EnQueue(Q,j);
			cout<<j<<" ";
		}
	cout<<endl<<"依次出链队的元素为："<<endl;
	while(DeQueue(Q,e) == OK)
	{
		cout<<e<<" ";
	}
	return 0;
}
实验结果：
4．采用顺序存储实现循环队列的初始化、入队、出队操作。
存储结构：
typedef int QElemType;
typedef int Status;
typedef struct{
	QElemType *base;
	int front;      //头指针
	int rear;       //尾指针
}SqQueue;
程序：
#include<iostream>
using namespace std;
#define MAXQSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int QElemType;
typedef int Status;
typedef struct{
	QElemType *base;
	int front;      //头指针
	int rear;       //尾指针
}SqQueue;
//循环队列的初始化
Status InitQueue(SqQueue &Q)
{
	Q.base = new QElemType[MAXQSIZE];
	if(!Q.base)
	{
		return OVERFLOW;
	}
	Q.front = Q.rear=0;
	return OK;
}
//循环队列的入队
Status EnQueue(SqQueue &Q,QElemType e)
{
	if((Q.rear+1)%MAXQSIZE == Q.front)
	{
		return ERROR;//队列满
	}
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear+1)%MAXQSIZE;
	return OK;
}
//循环队列的出队
Status DeQueue(SqQueue &Q,QElemType &e)
{
	if(Q.rear == Q.front)
	{
		return ERROR;
	}
	e = Q.base[Q.front];
	Q.front = (Q.front+1)%MAXQSIZE;
	return OK;
}
int main()
{
	SqQueue Q;
	QElemType e;
	cout<<"进循环队列的元素依次为："<<endl;
	if(InitQueue(Q)==OK)
		for(int j=1;j<=18;j++)
		{
			EnQueue(Q,j);
			cout<<j<<" ";
		}
	cout<<endl<<"依次出队的元素为："<<endl;
	while(Q.rear != Q.front)
	{
		DeQueue(Q,e);
		cout<<e<<" ";
	}
	return 0;
}
实验结果：

 

 

 

进朱者赤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
数据结构day3
yayyy4的博客
07-21 137
数据结构day3
#数据结构#第三章：栈
vircorns的博客
09-21 2023
第二章：链表判断题 判断题 1-1.通过对堆栈S操作：Push(S,1), Push(S,2), Pop(S), Push(S,3), Pop(S), Pop(S)。输出的序列为：123。 F 1-2.若一个栈的输入序列为1，2，3，…，N，输出序列的第一个元素是i，则第j个输出元素是j−i−1。 (2分) F 1-3.若一个栈的输入序列为{1, 2, 3, 4, 5}，则不可能得到{3,...
实现顺序栈的初始化、入栈和出栈操作
热门推荐
ancientear的博客
05-04 4万+
编写一个程序实现顺序栈的初始化、入栈和出栈操作； //方案1 # include&amp;amp;lt;stdlib.h&amp;amp;gt; #include&amp;amp;lt;iostream&amp;amp;gt; using namespace std; # define STACK_INIT_SIZE 20 # define stackincrement 20/*不是动态分配存储空间，所以需要定义一个增量*/ typedef int
数据结构——栈和队列详细解释
m0_61886762的博客
09-24 2292
你们在使用电脑中也会经历过机器有时会处于疑似死机的状态，鼠标点什么地方都没有任何反应，双击任何快捷键都不动弹。就当你失去内心时，机器突然对你刚的所有操作都执行了一遍。这是因为操作系统在当时可能CPU没有忙过来。操作系统中应用了一种数据结构来实现上述所说的问题也就是先进先出的功能，这就是队列。队列是一种先进先出的线性表简称FIFO。允许插入的操作为队尾，允许删除的操作为队头。就类似于最近几年的做核酸排队的操作，你在入队时是从队尾排队做核酸，做完之后是从队伍的头部做完后退出队伍。
数据结构——栈与队列
m0_57484470的博客
10-17 6059
数据结构栈与队列相关基础知识详解！！！
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64...
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
栈和队列的实现
09-16
用纯C模仿C++的class，结合栈和队列的，进行实现
栈与队列（超详细）
qq_45792749的博客
03-29 1万+
目录一、栈（Stack）什么是栈？栈的常见方法一级目录一级目录 一、栈（Stack） 什么是栈？ 栈其实就是一种数据结构 - 先进后出（先入栈的数据后出来，最先入栈的数据会被压入栈底） 什么是java虚拟机栈？ java虚拟机栈只是JVM当中的一块内存，该内存一般用来存放 例如：局部变量 当调用函数时，我们会为函数开辟一块内存，叫做 栈帧，在 java虚拟机栈中开辟，具体如下。 常见考点：不可能的出栈顺序 这道题该怎么分析呢？ 首先我们知道，出栈时拿到的第一个元素为4，那么4必须入栈，因为入栈的顺序是
采用链式存储实现队列的初始化、入队、出队操作。
cddchina的专栏
04-19 2万+
#include #include #define OVERFLOW -2 typedef struct QNode{//创建队成员  int  data;//数据成员  struct QNode *next; }QNode,*QueuePtr; typedef struct{//队头队尾指针  QueuePtr  front;  QueuePtr  rear; }LinkQu
数据结构实验课_实验四 队列
zavay的博客
12-28 3598
一、实验内容 1．采用顺序存储实现循环队列的初始化、入队、出队操作。 2．采用链式存储实现队列的初始化、入队、出队操作。 3．编写一个程序，使用两个链队q1和q2，用来分别存储由计算机随机产生的20个100以内的奇数和偶数，然后每行输出q1和q2的一个值，即奇数和偶数配对输出，直到任一队列为空为止。 顺序存储 代码实现: #include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 //最大队列长度 typedef int E
数据结构之栈和队列
容铎的博客
05-18 1273
数据结构之栈和队列
数据结构----栈和队列
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
05-19 1389
栈篇 1.1栈 栈，线性表的一种特殊的存储结构。与学习过的线性表的不同之处在于栈只能从表的固定一端对数据进行插入和删除操作，另一端是封死的。由于栈只有一边开口存取数据，称开口的那一端为“栈顶”，封死的那一端为“栈底”（类似于盛水的木桶，从哪进去的最后还得从哪出来）。 1.2.栈操作数据元素的两种动作： 数据元素用栈的数据结构存储起来，称为“入栈”，也叫“压栈”。 数据元素由于某种原因需要从栈结构中提取出来，称为“出栈”，也叫“弹栈”。 注意：栈遵循先进后出原则 1.3.栈的表示方式 既然栈
【Python数据结构系列】❤️《栈（顺序栈与链栈）》——❤️知识点讲解+代码实现
码农-Vax天道的时间宝藏
08-06 3883
灵魂拷问：为什么要学数据结构？ 数据结构，直白地理解，就是研究数据的存储方式。数据存储只有一个目的，即为了方便后期对数据的再利用。因此，数据在计算机存储空间的存放，决不是胡乱的，这就要求我们选择一种好的方式来存储数据，而这也是数据结构的核心内容。 可以说，数据结构是一切编程的基本。学习数据结构是学习一种思想：如何把现实问题转化为计算机语言的表示。 对于学计算机的朋友来说，学习数据结构是基本功。而对于非计算机专业，但是未来想往数据分析、大数据方向发展、或者在Python的使用上能有一个大的跨越的朋友来说，学.
【数据结构】栈和队列详细分析（全）
码农研究僧的博客
05-05 1万+
前言 栈和队列是两种重要的线性结构。从数据结构角度看，栈和队列也是线性表， 其特殊性在于栈和队列的基本操作是线性表操作的子集，它们是操作受限的线性表，因此，可称为限定性的数据结构。 栈的定义与特点 栈是限定仅在表尾进行插入或删除操作的线性表。 表尾称为栈顶,表头端称为栈底 。不含元素的空表称为空栈。栈的修改是按后进先出的原则进行的。 栈的操作 队列的定义与特点 和栈相反，队列是一种先进先出的线性表。它只允许在表的一端进行插入，而在另一端删除元素，允许插入的一端称为队尾，允许删除的一端则称为队头。 ...
python数据结构栈与队列
最新发布
04-27
栈（stack）和队列（queue）都是常见的数据结构，它们可以用来解决很多实际问题。 栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构，类似于一个垂直的栈，只能在顶部进行插入和删除元素的操作。栈的主要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

进朱者赤

多多支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值